Java プラットフォームでは、暗号化、公開鍵インフラストラクチャー、認証、安全な通信、アクセス制御など、主要なセキュリティー分野に渡る一連の API が定義されています。これらの API によって、開発者はアプリケーションコードにセキュリティーを簡単に統合できます。これらは、次の方針に基づいて設計されました。

1. 実装の独立性

   アプリケーションでセキュリティーを実装する必要はありません。Java プラットフォームからセキュリティーサービスを要求できます。セキュリティーサービスはプロバイダ (次を参照) に実装されています。プロバイダは、標準インタフェースによって Java プラットフォームにプラグインされます。アプリケーションは、複数の独立したプロバイダにセキュリティー機能を依存する場合があります。

2. 実装の相互運用性

   プロバイダは、アプリケーション間で相互運用できます。具体的には、アプリケーションは特定のプロバイダにバインドされず、プロバイダは特定のアプリケーションにバインドされません。

3. アルゴリズムの拡張性

   Java プラットフォームには、現在広く使用されている基本的なセキュリティーサービスを実装する多数の組み込みプロバイダが含まれています。ただし、一部のアプリケーションは、まだ実装されていない普及しつつある規格や独自のサービスに依存している場合があります。Java プラットフォームは、そのようなサービスを実装するカスタムプロバイダのインストールをサポートします。

「暗号化サービスプロバイダ」(プロバイダ) は、JDK Security API の暗号化に関するサブセットの固定実装を提供するパッケージ (またはパッケージセット) です。

java.security.Provider クラスは、セキュリティープロバイダの概念を Java プラットフォームでカプセル化します。プロバイダの名前を指定し、実装するセキュリティーサービスを一覧します。複数のプロバイダが同時に構成される場合があり、それらは優先順に一覧されます。セキュリティーサービスが要求されると、そのサービスを実装する、優先順位がいちばん高いプロバイダが選択されます。

図 1 および図 2 は、MD5 メッセージダイジェスト実装を要求するための、これらのオプションを示しています。どちらの図も、メッセージダイジェストアルゴリズムを実装する 3 つのプロバイダを示しています。プロバイダは、左から右への優先順位 (1 から 3) で並べられています。図 1 では、アプリケーションはプロバイダ名を指定せずに MD5 アルゴリズム実装を要求しています。プロバイダが優先順位に従って検索され、その特定のアルゴリズムを提供する最初のプロバイダである ProviderB から実装が返されます。図 2 では、アプリケーションは特定のプロバイダである ProviderC から MD5 アルゴリズム実装を要求しています。この場合は、優先順位の高いプロバイダである ProviderB も MD5 実装を提供しますが、指定されたプロバイダから実装が返されます。

図 1 (左): プロバイダの検索。図 2 (右): 特定のプロバイダの要求

各インストールでは 1 つ以上のプロバイダパッケージがインストールされます。クライアントは異なるプロバイダを用いて実行環境を構成し、各プロバイダの優先順位を指定できます。優先順位とは、特定プロバイダの指定がないときに、要求アルゴリズムについてプロバイダを検索する順序です。

Sun が提供する Java Runtime Environment には、「SUN」という名前のデフォルトのプロバイダが標準で搭載されています。ほかの Java Runtime Environment には、「SUN」プロバイダが含まれない場合があります。

このドキュメントの対象読者

Java Security API を使って既存の暗号化アルゴリズムやほかのサービスにアクセスするだけであれば、このドキュメントを読む必要はありません。

このドキュメントは、暗号化サービス実装を提供する独自のプロバイダパッケージを作成する上級プログラマを対象としています。ここでは、Java Security API クライアントが、作成されたアルゴリズムやほかのサービスを要求する際にそれらを検出できるよう、プロバイダを Java に統合するための方法がドキュメント化されています。

関連項目

このドキュメントは、読者がすでに「Java 暗号化アーキテクチャーリファレンスガイド」を読んでいることを前提としています。

Security API のさまざまなクラスおよびインタフェースを含むパッケージについてドキュメント化されています。

• java.security
• java.security.spec
• java.security.interfaces
• javax.crypto
• javax.crypto.spec
• javax.crypto.interfaces

用語に関する注記

• JDK 1.4 より前は、JCE はバンドルされていない製品であり、そのため、JCA と JCE は常に別個のコンポーネントとして参照されていました。現在 JCE は JDK にバンドルされているため、区別は明確でなくなってきています。JCE は JCA と同じアーキテクチャーを使用するため、JCE は JCA のサブセットとして考えることができます。
• JDK の JCA には、次の 2 つのソフトウェアコンポーネントが含まれます。
  • プロバイダが実装を提供可能な暗号化サービスを定義およびサポートするフレームワーク。このフレームワークには、java.security、javax.crypto、javax.crypto.spec、javax.crypto.interfaces などのパッケージが含まれます。
  • Sun、SunRsaSign、SunJCE などの実際のプロバイダ。実際の暗号化実装が含まれます。

このドキュメントでは、JCA という語は、JCA フレームワークを指して使用されています。このドキュメントで特定の JCA プロバイダを取り上げる場合は、常にプロバイダ名で明示的に指定されます。

エンジンクラスは、固定実装のない抽象的な方法で暗号化サービスを定義します。

暗号化サービスは、常に特定のアルゴリズムまたは型に関連付けられています。このサービスによって、暗号化の操作 (デジタル署名またはメッセージダイジェスト、暗号または鍵協定プロトコルなどのための操作) の提供、暗号化の操作に必要な暗号化データ (鍵またはパラメータ) の生成や提供、あるいは暗号化の操作で使用する暗号化鍵を安全にカプセル化するデータオブジェクト (キーストアまたは証明書) の生成が行われます。

たとえば、次の 4 つのエンジンクラスがあります。

• Signature クラスは、デジタル署名アルゴリズムの機能へのアクセスを提供します。
• DSA KeyFactory クラスは、(エンコード形式または透明な仕様から) DSA 非公開鍵または公開鍵を、それぞれ DSA Signature オブジェクトの initSign または initVerify メソッドから利用可能な形式で提供します。
• Cipher クラスは、DES などの暗号化アルゴリズムの機能へのアクセスを提供します。
• KeyAgreement クラスは、Diffie-Hellman などの鍵協定プロトコルの機能へのアクセスを提供します。

Java 暗号化アーキテクチャーには、エンジンクラスなど、暗号化に関連するセキュリティーパッケージを構成するクラスが含まれています。API のユーザーは、エンジンクラスを要求および利用して対応する処理を実行します。JDK は、次のエンジンクラスを定義します。

• MessageDigest - 指定データのメッセージダイジェスト (ハッシュ) の計算に使います。
• Signature - デジタル署名の署名および検証に使います。
• KeyPairGenerator - 指定のアルゴリズムに適合した、公開鍵、非公開鍵ペアの生成に使います。
• KeyFactory - Key 型の不透明な暗号化鍵を鍵仕様 (基本の鍵データの透明な表現) に変換したり、その逆の変換を行うために使用します。
• KeyStore - キーストアの作成および管理に使用します。キーストアは、鍵のデータベースです。キーストア内の非公開鍵には、鍵に関連した証明書連鎖があります。証明書連鎖は、対応する公開鍵を認証します。また、キーストアには、信頼できるエンティティーからの証明書も格納されています。
• CertificateFactory - 公開鍵の証明書および証明書の取り消しリスト (CRL) の作成に使用します。
• AlgorithmParameters - パラメータのエンコードおよびデコードなど、特定のアルゴリズムのパラメータ管理に使います。
• AlgorithmParameterGenerator - 特定のアルゴリズムに適したパラメータセットの生成に使います。
• SecureRandom - 乱数または擬似乱数の生成に使用します。
• Cipher - 指定されたデータの暗号化または復号化に使用します。
• KeyAgreement - 複数のパーティー間の鍵協定 (鍵交換) プロトコルの実行に使用します。
• KeyGenerator - 指定のアルゴリズムに適合した、秘密 (対称) 鍵の生成に使用します。
• Mac - 指定されたデータのメッセージ認証コードの計算に使用します。
• SecretKeyFactory - SecretKey 型の不透明な暗号化鍵を鍵仕様 (基本の鍵データの透明な表現) に変換したり、その逆の変換を行うために使用します。
• ExemptionMechanism - 鍵復元、鍵弱化、鍵エスクローなどの免責メカニズム、またはほかの (カスタム) 免責メカニズムの機能を提供するために使用します。免責メカニズムを使用するアプリケーションまたはアプレットは、使用しないアプリケーションまたはアプレットに比べて強力な暗号化機能が付与されます。大半の国では暗号化制限はもはや適用されていないため、免責メカニズムが有用なのは政府により制限が要求されているいくつかの国だけです。

注:ジェネレータ (generator) は、最新の内容でオブジェクトを作成しますが、ファクトリ (factory) は既存の構成要素 (エンコードなど) からオブジェクトを作成します。

エンジンクラスは、(特定の暗号化アルゴリズムに依存しない) 特定の型の暗号化サービス機能へのインタフェースを提供します。これにより、Application Programming Interface (API) メソッドが定義され、API が提供する特定の種類の暗号化サービスにアプリケーションがアクセスできるようになります。実際の実装 (1 つ以上のプロバイダから) は特定アルゴリズムのためのものです。たとえば Signature エンジンクラスは、デジタル署名アルゴリズムの機能へのアクセスを提供します。SignatureSpi サブクラス (次の段落を参照) に実際に提供される実装は、DSA を使用する SHA-1、RSA を使用する SHA-1、または RSA を使用する MD5 などの特定の種類の署名アルゴリズムとなります。

エンジンクラスが提供するアプリケーションインタフェースは、Service Provider Interface (SPI) として実装されます。つまり、各エンジンクラスに対応する抽象 SPI クラスが存在し、抽象 SPI クラスによって暗号化サービスプロバイダが実装しなければならない Service Provider Interface のメソッドが定義されます。

エンジンクラスのインスタンスである「API オブジェクト」は、対応する SPI クラスのインスタンスである「SPI オブジェクト」を private フィールドとしてカプセル化します。API オブジェクトのすべての API メソッドは、「final」として宣言し、それらを実装することによって、カプセル化される SPI オブジェクトの対応する SPI メソッドが呼び出されます。エンジンクラス (およびそれに対応する SPI クラス) のインスタンスは、エンジンクラスの getInstance ファクトリメソッドへの呼び出しによって作成されます。

各 SPI クラスの名前は、対応するエンジンクラス名のあとに「Spi」を追加した名前になります。たとえば、Signature エンジンクラスに対応する SPI クラスは、SignatureSpi クラスです。

各 SPI クラスは、抽象クラスです。指定したアルゴリズムに対する特定の型のサービスの実装を提供するには、プロバイダは、対応する SPI クラスをサブクラス化して、すべての抽象メソッドの実装を提供する必要があります。

エンジンクラスの別の例に MessageDigest クラスがあります。このクラスは、メッセージダイジェストアルゴリズムへのアクセスを提供します。MessageDigestSpi サブクラスでのこのクラスの実装は、SHA-1、MD5、または MD2 などの各種メッセージダイジェストアルゴリズムにできます。

さらに別の例として、KeyFactory エンジンクラスは、不透明な鍵から透明な鍵仕様への変換、またはその逆の変換をサポートします。詳細は、「鍵ファクトリにより要求される鍵仕様のインタフェースおよびクラス」を参照してください。KeyFactorySpi サブクラスで提供される現実の実装は、DSA 公開鍵または非公開鍵などの、特定の種類の鍵のための実装です。

次の手順に従って、プロバイダを実装し JCA フレームワークに統合します。

ステップ 1:サービス実装コードの記述

最初に、サポートする暗号化サービスのアルゴリズム固有の実装を提供するコードを記述する必要があります。

プロバイダは、JDK の 1 つ以上のセキュリティーコンポーネントですでに使用可能になっている暗号化サービス実装を提供できます。

JCA には定義されていない暗号化サービス (署名やメッセージダイジェストなど) に関しては、「Java 暗号化アーキテクチャーリファレンスガイド」を参照してください。

実装する暗号化サービスごとに、適切な SPI クラスのサブクラスを作成します。JCA は、次のエンジンクラスを定義します。

• SignatureSpi
• MessageDigestSpi
• KeyPairGeneratorSpi
• SecureRandomSpi
• AlgorithmParameterGeneratorSpi
• AlgorithmParametersSpi
• KeyFactorySpi
• CertificateFactorySpi
• KeyStoreSpi
• CipherSpi
• KeyAgreementSpi
• KeyGeneratorSpi
• MacSpi
• SecretKeyFactorySpi
• ExemptionMechanismSpi

JCA およびその他の暗号化クラスについては、このドキュメントの「エンジンクラスおよび対応する SPI クラス」を参照してください。

サブクラスで、次を実行する必要があります。

1. 通常 engine で始まる名前を持つ抽象メソッド用の実装を提供します。詳細は、「実装の詳細および要件」を参照してください。
2. 引数を持たない public コンストラクタの存在を確認します。理由は次のとおりです。これが必要な理由は、サービスの要求時に、Java Security が、マスタークラス内のプロパティーによる指定に従って、そのサービスを実装するサブクラスを検索するためです (ステップ 3 を参照)。そのあと、Java Security は、サブクラスに関連付けられた Class オブジェクトを作成し、その Class オブジェクトに対して newInstance メソッドを呼び出すことにより、サブクラスのインスタンスを作成します。newInstance はサブクラスがパラメータを持たない public コンストラクタを保持することを要求します。
3. サブクラスがコンストラクタを持たない場合、引数を持たないデフォルトのコンストラクタが自動的に生成されます。ただし、サブクラスがコンストラクタを定義する場合、引数を持たない public コンストラクタを明示的に定義する必要があります。

ステップ 1.1:暗号化実装のための JCA プロバイダの追加要件および推奨事項

プロバイダによる Cipher、KeyAgreement、KeyGenerator、MAC または SecretKey ファクトリの実装 (クラス) をインスタンス化する際、フレームワークはプロバイダのコードベース (JAR ファイル) を判定し、その署名を検証します。このようにして、JCA はプロバイダを認証して、信頼されたエンティティーにより署名されたプロバイダだけが JCA にプラグインできるようにします。このため、暗号化プロバイダは署名付きにする必要があります。詳細は後のステップで説明します。

また、各プロバイダは自己整合性チェックを実行して、プロバイダメソッドを JCA を介さずに直接呼び出そうとして、コードを含む JAR ファイルが操作されていないことを保証する必要があります。詳細は、「プロバイダによる自己整合性チェックの実行方法」を参照してください。

JCA を介さずに直接アプリケーションからインスタンス化が行われた場合に、プロバイダクラスを使用不可にするため、プロバイダは次の実装を行う必要があります。

• プロバイダパッケージ内のすべての SPI 実装クラスを final として宣言し (サブクラス化できないように)、SPI 実装メソッドを protected として宣言する必要があります。
• プロバイダパッケージ内の暗号化関連ヘルパークラスはすべて、プロバイダパッケージ外からアクセスできないように、パッケージ独自のスコープを保持する必要があります。

プロバイダを米国以外に輸出する場合、CipherSpi 実装に、Key を指定すると鍵のサイズを返す engineGetKeySize メソッドの実装を含める必要があります。管轄ポリシーファイルで指定された利用可能な暗号化強度に制限が設定されている場合、Cipher 初期化メソッドは engineGetKeySize を呼び出して、実行中のアプレットまたはアプリケーションの特定位置および状況での鍵の最大有効サイズと結果を比較します。鍵のサイズが大きすぎる場合には、初期化メソッドにより例外がスローされます。

プロバイダが実装可能なオプション機能を、次に示します。

• CipherSpi の engineWrap メソッドおよび engineUnwrap メソッド。鍵をラッピングすると、ある場所から別の場所へ安全に転送できます。鍵のラップおよびラップの解除の詳細は、「Java 暗号化アーキテクチャーリファレンスガイド」の「鍵のラッピングとアンラッピング」のセクションを参照してください。
• 1 つ以上の免責メカニズム。免責メカニズムには、鍵復元、鍵エスクロー、鍵弱化などが含まれます。このメカニズムを実装および実行すると、これを利用するアプリケーション (またはアプレット) に対する暗号化の制限を緩めることができます。免責メカニズムを利用するアプリケーションの要件に関する詳細は、「Java 暗号化アーキテクチャーリファレンスガイド」の「アプリケーションの暗号化制限の「免責」を取得する方法」を参照してください。

ステップ 2:プロバイダの命名

使用するプロバイダの名前を特定します。これは、クライアントアプリケーションがプロバイダを参照する際に使用する名前です。

ステップ 3:プロバイダのサブクラスであるマスタークラスの記述

3 番目のステップは、java.security.Provider クラスのサブクラスを作成することです。

このサブクラスは final にする必要があり、そのコンストラクタは次を実行する必要があります。

• super を呼び出して、プロバイダ名 (ステップ 2 を参照)、バージョン番号、およびプロバイダおよびプロバイダがサポートするアルゴリズムに関する情報を指定します。たとえば、

      super("CryptoX", 1.0, "CryptoX provider v1.0, implementing " +
          "RSA encryption and key pair generation, and DES encryption.");
  

• Java Security API がプロバイダにより実装された暗号化サービスを検索するために必要とされる、さまざまなプロパティーの値を設定します。プロバイダによるサービス実装ごとに、サービスの型 (Signature、MessageDigest、Cipher、KeyAgreement など) Signature、MessageDigest、KeyPairGenerator、SecureRandom、KeyFactory、KeyStore、CertificateFactory、AlgorithmParameterGenerator、AlgorithmParameters、Cipher、KeyAgreement、KeyGenerator、Mac、SecretKeyFactory、または ExemptionMechanism)、ピリオド、およびサービスが適用されるアルゴリズム名で構成される名前のプロパティーが必要です。プロパティーの値には、サービスを実装するクラスの完全修飾名を指定する必要があります。

• 次のリストに、JCA サービスのさまざまな型を示します。algName は、実際のアルゴリズム名に置き換えてください。

  • Signature.algName
  • MessageDigest.algName
  • KeyPairGenerator.algName
  • SecureRandom.algName
  • AlgorithmParameterGenerator.algName
  • AlgorithmParameters.algName
  • KeyFactory.algName
  • CertificateFactory.algName
  • KeyStore.algName
  • Cipher.algName
  • KeyAgreement.algName
  • KeyGenerator.algName
  • Mac.algName
  • SecretKeyFactory.algName
  • ExemptionMechanism.algName

  ExemptionMechanism および Cipher を除き、これらのどの場合にも algName、certType、または storeType は、アルゴリズム、証明書の型、またはキーストアの型の「標準」名です。使用する必要がある標準名については、「Java 暗号化アーキテクチャーリファレンスガイド」の「付録 A」を参照してください。

  ExemptionMechanism の場合、algName は例外メカニズムの名前を指し、KeyRecovery、KeyEscrow、または KeyWeakening。大文字小文字は区別されません。

  Cipher の場合、algName は実際には変換を表します。これは、アルゴリズム名、指定されたモード、およびパディングスキームで構成されます。詳細は、「Java 暗号化アーキテクチャーリファレンスガイド」の「付録 A」を参照してください。

  各プロパティーの値は、指定されたアルゴリズム、証明書の型、またはキーストアの型を実装するクラスの完全修飾名である必要があります。つまり、クラス名のあとにピリオドとパッケージ名が記述されていなければなりません。

  たとえば、SUN という名前のデフォルトプロバイダは、sun.security.provider パッケージの DSA という名前のクラス内のデジタル署名アルゴリズム (その標準名は SHA1withDSA) を実装します。Provider のサブクラス (sun.security.provider package の Sun クラス) は、次のようにして、Signature.SHA1withDSA プロパティーが値 sun.security.provider.DSA を保持するよう設定します。

      put("Signature.SHA1withDSA", "sun.security.provider.DSA")
  

  次のリストに、さまざまな種類のサービスに合わせて定義可能なその他のプロパティーを示します。実際には、algName はアルゴリズム名に、certType は証明書の型に、storeType はキーストアの型に、attrName は属性名に置き換えられます。

  • Signature.algName [one or more spaces] attrName
  • MessageDigest.algName [one or more spaces] attrName
  • KeyPairGenerator.algName [one or more spaces] attrName
  • SecureRandom.algName [one or more spaces] attrName
  • KeyFactory.algName [one or more spaces] attrName
  • CertificateFactory.certType [one or more spaces] attrName
  • KeyStore.storeType [one or more spaces] attrName
  • AlgorithmParameterGenerator.algName [one or more spaces] attrName
  • AlgorithmParameters.algName [one or more spaces] attrName
  • Cipher.algName [one or more spaces] attrName
  • KeyAgreement.algName [one or more spaces] attrName
  • KeyGenerator.algName [one or more spaces] attrName
  • Mac.algName [one or more spaces] attrName
  • SecretKeyFactory.algName [one or more spaces] attrName
  • ExemptionMechanism.algName [one or more spaces] attrName

これらのどの場合にも、algName、certType、storeType、または attrName は、アルゴリズム、証明書の型、キーストアの型、または属性の「標準」名です。使用するべき標準名については、「Java 暗号化アーキテクチャーリファレンスガイド」の「付録 A」を参照してください。

前述の形式のプロパティーの場合、プロパティーの値は、対応する属性に応じた値である必要があります。(各標準属性の定義については、「Java 暗号化アーキテクチャー API 仕様 & リファレンス」の「付録 A」を参照してください。)

たとえば、「SUN」という名前のデフォルトプロバイダは、SHA1withDSA Digital デジタル署名アルゴリズムをソフトウェア内で実装します。プロバイダ「SUN」のマスタークラスでは、次のようにして、Signature.SHA1withDSA ImplementedIn が値 Software を保持するように設定が行われます。

    put("Signature.SHA1withDSA ImplementedIn", "Software")

マスタークラスプロパティーの設定例の詳細は、「付録 A」を参照して現在の Sun.java のソースファイルを閲覧するか、「付録 B」を参照して SunJCE プロバイダを参照してください。これらのファイルでは、Sun および SunJCE プロバイダがプロパティーをどのように設定しているかがわかります。

メッセージダイジェストおよび MAC アルゴリズムごとに、実装が複製可能かどうかを指定します。これは、技術的には必須ではありませんが、複製による中間メッセージダイジェストまたは MAC が可能かどうかを指定することになるため、クライアントの費やす時間およびコードの記述にかかる手間が軽減されます。MessageDigest または Mac の実装が複製可能かどうかがわからない場合、クライアントはオブジェクトの複製を試みて、発生する可能性のある例外をキャッチすることにより、複製可能かどうかを識別できます。次にその例を示します。

    try {
        // try and clone it
        /* compute the MAC for i1 */
        mac.update(i1);
        byte[] i1Mac = mac.clone().doFinal();

        /* compute the MAC for i1 and i2 */
        mac.update(i2);
        byte[] i12Mac = mac.clone().doFinal();

        /* compute the MAC for i1, i2 and i3 */
        mac.update(i3);
        byte[] i123Mac = mac.doFinal();
    } catch (CloneNotSupportedException cnse) {
        // have to use an approach not involving cloning
    } 

次にそれぞれの意味を示します。

• mac は、Mac.getInstance への呼び出しを介して要求が行われた場合に、受け取られる MAC オブジェクトです。
• i1、i2 および i3 は、入力バイト配列です。
• 次について、別々のハッシュを計算します。
  • i1
  • i1 and i2
  • i1, i2, and i3

鍵ペアジェネレータ

鍵ペアジェネレータアルゴリズムでは、クライアントが (initialize メソッドの呼び出しを介して) 明示的に鍵ペアジェネレータを初期化しない場合、各プロバイダはデフォルトの初期化を提供およびドキュメント化する必要があります。たとえば、SunJCE プロバイダにより提供される Diffie-Hellman 鍵ペアジェネレータは、1024 ビットのデフォルト素数モジュラスサイズ (keysize) を使用します。

鍵ファクトリ

プロバイダは、その (秘密) 鍵ファクトリがサポートするすべての鍵仕様をドキュメント化する必要があります。

アルゴリズムパラメータジェネレータ

クライアントが AlgorithmParameterGenerator エンジンクラスの init メソッドの呼び出しを介してアルゴリズムパラメータジェネレータを明示的に初期化しない場合、各プロバイダはデフォルトの初期化を行い、これをドキュメント化する必要があります。たとえば、SunJCE プロバイダは、Diffie-Hellman パラメータの生成に 1024 ビットのデフォルト素数モジュラスサイズ (keysize) を使用し、SUN プロバイダは、DSA パラメータの生成に 1024 ビットのデフォルトモジュラス素数サイズを使用します。

署名アルゴリズム

署名アルゴリズムを実装する場合、署名 (sign メソッドの 1 つを使って生成される) をエンコードする形式をドキュメント化する必要があります。たとえば、「SUN」プロバイダにより提供される SHA1withDSA 署名アルゴリズムは、署名を、2 つの整数 r および s の標準 ASN.1 SEQUENCE としてエンコードします。

乱数生成 (SecureRandom) アルゴリズム

乱数生成アルゴリズムの場合、生成される数がどのように「ランダム」なのかを示す情報、および乱数ジェネレータの自己シード時のシードの質に関する情報を提供します。同時に、SecureRandom オブジェクト (およびそのカプセル化された SecureRandomSpi 実装オブジェクト) の直列化解除時に、何が発生するかにも留意してください。復元されたオブジェクトの nextBytes メソッド (カプセル化された SecureRandomSpi オブジェクトの engineNextBytes メソッドを呼び出す) への続く呼び出しにより、元のオブジェクトが生成するのと正確に同じ (ランダム) バイトが生成される場合、この動作が望ましくないのであれば、setSeed メソッドを呼び出して復元されたランダムオブジェクトにシードをするよう、ユーザーに通知してください。

証明書ファクトリ

プロバイダは、ファクトリが作成可能な証明書の種類 (および必要に応じてそのバージョン番号) をドキュメント化する必要があります。

キーストア

プロバイダは、キーストアの実装に関するすべての関連情報 (ベースとなるデータ形式など) をドキュメント化する必要があります。

ステップ 12:クラスファイルおよびドキュメントをクライアントから利用可能にする

プロバイダソフトウェアの記述、構成、テスト、インストール、およびドキュメント化のあとで、ドキュメントをカスタマから利用可能にします。

別名

多くの暗号化のアルゴリズムおよび型には、「Java 暗号化アーキテクチャーリファレンスガイド」の「付録 A」で定義された公式な「標準名」が 1 つ存在します。

たとえば、「MD5」は、RFC 1321 の RSA DSI で定義された RSA-MD5 メッセージダイジェストアルゴリズムの標準名です。DiffieHellman は、PKCS3 で定義された Diffie-Hellman 鍵協定アルゴリズムの標準です。

JDK では、アルゴリズムまたは型への参照時に、クライアントが標準名ではなく別名を使用することを可能にするエイリアス化スキームが存在します。たとえば、「SUN」プロバイダのマスタークラス (Sun.java) は、標準名が「SHA1withDSA」であるアルゴリズムの別名「SHA1/DSA」を定義します。このため、次の文は同じ意味になります。

    Signature sig = Signature.getInstance("SHA1withDSA", "SUN");

    Signature sig = Signature.getInstance("SHA1/DSA", "SUN");

別名は、「マスタークラス」内で定義できます (ステップ 3 を参照)。別名を定義するには、次の名前のプロパティーを作成します。

    Alg.Alias.engineClassName.aliasName

engineClassName にはエンジンクラス (Signature など) の名前が、aliasName には設定する別名が当てはまります。プロパティーの値は、別名を設定するアルゴリズム (または型) の標準アルゴリズム (または型) 名でなければなりません。

例として、「SUN」プロバイダが、Alg.Alias.Signature.SHA1/DSA という名前のプロパティーに値 SHA1withDSA を設定することにより、標準名が SHA1withDSA である署名アルゴリズムに別名「SHA1/DSA」を定義する場合を考えましょう。次にそのコードを示します。

    put("Alg.Alias.Signature.SHA1/DSA", "SHA1withDSA");

あるプロバイダによって定義された別名は、そのプロバイダのみが使用でき、その他のプロバイダは使用できません。したがって、SunJCE プロバイダによって定義された別名は、SunJCE プロバイダのみが使用できます。

サービスの相互依存性

アルゴリズムによっては、ほかの種類のアルゴリズムの使用を要求することがあります。たとえば、通常、PBE アルゴリズムは、メッセージダイジェストアルゴリズムを使用して、パスワードを鍵に変換する必要があります。

別のアルゴリズムを要求するアルゴリズムを実装している場合、次のいずれかを実行できます。

1. どちらのアルゴリズムにも対応した独自の実装の提供。
2. すべての Java SE プラットフォームのインストールに含まれるデフォルトの SUN プロバイダにより提供される場合のように、一方のアルゴリズムの実装が他方のアルゴリズムのインスタンスを使用するようにします。たとえば、実装している PBE アルゴリズムがメッセージダイジェストアルゴリズムを要求する場合、次の呼び出しを行うことにより、MD5 メッセージダイジェストアルゴリズムを実装するクラスのインスタンスを取得できます。

       MessageDigest.getInstance("MD5", "SUN")
   
   

3. 別の特定のプロバイダにより提供される場合のように、一方のアルゴリズムの実装が他方のアルゴリズムのインスタンスを使用するようにします。これは、プロバイダを使用するすべてのクライアントが、インストールされた他方のプロバイダも保持する場合にだけ有効な方法です。
4. 別の (無指定の) プロバイダにより提供される場合のように、一方のアルゴリズムの実装が他方のアルゴリズムのインスタンスを使用するようにします。つまり、アルゴリズムを名前で要求できます。ただし、特定のプロバイダは指定しません。次に例を示します。

       MessageDigest.getInstance("MD5")
   
   

   これは、プロバイダが使用される各 Java プラットフォームにインストールされた、要求されたアルゴリズムの実装 (この例では MD5) が少なくとも 1 つ存在することが確実な場合にだけ有効な方法です。

次に、アルゴリズムの相互依存の一般的な種類を示します。

署名アルゴリズムとメッセージダイジェストアルゴリズム

署名アルゴリズムは、メッセージダイジェストアルゴリズムを必要とすることがあります。たとえば、SHA1withDSA 署名アルゴリズムは、SHA-1 メッセージダイジェストアルゴリズムを必要とします。

署名アルゴリズムと (擬似) 乱数生成アルゴリズム

署名アルゴリズムは、(擬似) 乱数生成アルゴリズムの使用を必要とすることがあります。たとえば、DSA 署名を生成するためには、対応する乱数生成アルゴリズムが必要です。

鍵のペア生成アルゴリズムとメッセージダイジェストアルゴリズム

鍵のペア生成アルゴリズムは、メッセージダイジェストアルゴリズムの使用を必要とすることがあります。たとえば、DSA 鍵は、SHA-1 メッセージダイジェストアルゴリズムを使って生成されます。

アルゴリズムパラメータ生成とメッセージダイジェストアルゴリズム

アルゴリズムパラメータジェネレータは、メッセージダイジェストアルゴリズムの使用を必要とすることがあります。たとえば、DSA パラメータは、SHA-1 メッセージダイジェストアルゴリズムを使って生成されます。

KeyStores とメッセージダイジェストアルゴリズム

キーストア実装は、メッセージダイジェストアルゴリズムを利用して鍵ハッシュ (key はユーザーが提供するパスワード) を計算し、キーストアの統合性検査、およびキーストアが改変されていないことを確認することがあります。

鍵のペア生成アルゴリズムとアルゴリズムパラメータジェネレータ

鍵のペア生成アルゴリズムは、新規アルゴリズムパラメータセットの生成を必要とする場合があります。パラメータは、直接生成するか、アルゴリズムパラメータジェネレータを使用して生成できます。

鍵のペア生成、アルゴリズムパラメータ生成、および (擬似) 乱数生成アルゴリズム

鍵のペア生成アルゴリズムは、新しい鍵ペアおよび (場合によっては) 鍵に関連付けられた新規パラメータセットの生成に、乱数の発生源を必要とする場合があります。乱数の発生源は、SecureRandom オブジェクトにより表されます。鍵ペア生成アルゴリズムの実装は、鍵パラメータ自体を生成する場合もあれば、アルゴリズムパラメータジェネレータを使って鍵パラメータを生成する場合もあります。これらの場合、乱数の発生源を使ってアルゴリズムパラメータジェネレータを初期化する場合もあれば、そうでない場合もあります。

アルゴリズムパラメータジェネレータおよびアルゴリズムパラメータ

アルゴリズムパラメータジェネレータの engineGenerateParameters メソッドは、AlgorithmParameters インスタンスを返す必要があります。

署名および鍵ペア生成アルゴリズムまたは鍵ファクトリ

署名アルゴリズムを実装している場合、実装の engineInitSign メソッドおよび engineInitVerify メソッドは、ベースとなるアルゴリズム (DSS アルゴリズム用の DSA 鍵など) に対して有効な、引き渡しの行われる鍵を必要とします。次のいずれかを実行できます。

1. 適切なインタフェースを実装する独自のクラス (java.security.interfaces パッケージから DSAPrivateKey および DSAPublicKey インタフェースを実装するクラスなど) も作成し、独自の鍵ペアのジェネレータとこれらの型の鍵を返す鍵ファクトリのどちらかまたは両方を作成します。engineInitSign および engineInitVerify に渡される鍵が、実装した鍵 (つまり、鍵ペアジェネレータまたは鍵ファクトリから生成された鍵) と同じ型である必要があります。または、次の方法も可能です。
2. ほかの鍵ペアジェネレータまたはほかの鍵ファクトリから鍵を受け取ります。これは、それらが署名の実装が必要な情報 (非公開鍵、公開鍵および鍵パラメータなど) を取得することを可能にする適切なインタフェースのインスタンスである場合にかぎり有効です。たとえば、DSS Signature クラス用の engineInitSign メソッドは、java.security.interfaces.DSAPrivateKey のインスタンスである任意の非公開鍵を受け取ることができます。

キーストアと鍵および証明書ファクトリ

キーストアの実装は、鍵ファクトリを利用してキーストアに格納された鍵の構文解析を行うことがあります。また、証明書ファクトリを利用してキーストアに格納された証明書の構文解析を行います。

デフォルトの初期化

クライアントが明示的に鍵ペアジェネレータまたはアルゴリズムパラメータジェネレータを初期化しない場合、これらサービスの各プロバイダはデフォルトの初期化を提供 (およびドキュメント化) する必要があります。たとえば、Sun プロバイダは、DSA パラメータの生成に 1024 ビットのデフォルトモジュラスサイズ (強度) を使用し、「SunJCE」プロバイダは、Diffie-Hellman パラメータの生成に 1024 ビットのデフォルトモジュラスサイズ (キーサイズ) を使用します。

デフォルトの鍵ペアジェネレータのパラメータの要件

鍵ペアジェネレータを実装する場合、クライアントがパラメータを指定しない場合は、実装がデフォルトのパラメータを提供する必要があります。提供するドキュメント (ステップ 11) で、デフォルトパラメータを指定する必要があります。

たとえば、SUN プロバイダの DSA 鍵ペアジェネレータは、512、768、および 1024 ビットの鍵ペア生成用に、計算済みの p、q、および g デフォルト値のセットを提供します。次の p、q、および g 値は、1024 ビット DSA 鍵ペア生成用のデフォルト値として使用されます。

p = fd7f5381 1d751229 52df4a9c 2eece4e7 f611b752 3cef4400 c31e3f80
    b6512669 455d4022 51fb593d 8d58fabf c5f5ba30 f6cb9b55 6cd7813b
    801d346f f26660b7 6b9950a5 a49f9fe8 047b1022 c24fbba9 d7feb7c6
    1bf83b57 e7c6a8a6 150f04fb 83f6d3c5 1ec30235 54135a16 9132f675
    f3ae2b61 d72aeff2 2203199d d14801c7

q = 9760508f 15230bcc b292b982 a2eb840b f0581cf5

g = f7e1a085 d69b3dde cbbcab5c 36b857b9 7994afbb fa3aea82 f9574c0b
    3d078267 5159578e bad4594f e6710710 8180b449 167123e8 4c281613
    b7cf0932 8cc8a6e1 3c167a8b 547c8d28 e0a3ae1e 2bb3a675 916ea37f
    0bfa2135 62f1fb62 7a01243b cca4f1be a8519089 a883dfe1 5ae59f06
    928b665e 807b5525 64014c3b fecf492a

(ここで指定された p および q 値は、素数生成標準により、次の 160 ビットのシードを使って生成されます。

SEED:  8d515589 4229d5e6 89ee01e6 018a237e 2cae64cd

このシードでは、カウンタが 92 の時に p および q を検出しました。)

Provider.Service クラス

導入されて以来、セキュリティープロバイダは Hashtable エントリに入力された適切なフォーマットの鍵と値の String ペアを使用して、サービス情報を公開してきました。このメカニズムはシンプルで簡便ですが、カスタマイズの範囲がかぎられています。そのため、JDK 5.0 では、2 番目のオプションとして、Provider.Service クラスが導入されました。これを利用して、プロバイダはサービスおよびサポートに、次で説明するような追加機能を通知できます。この追加機能は、String 値の HashTable エントリを使用する以前の方法と完全な互換性があることに留意してください。JDK 5.0 では、プロバイダはどちらの方法も選択でき、また同時に両方を使用することもできます。

Provider.Service オブジェクトは、サービスに関するすべての情報をカプセル化します。このプロバイダは、サービス、型 (MessageDigest、Signature など)、アルゴリズム名、およびサービスを実装するクラス名を提供します。また、このサービス (別名) および属性に対する代替アルゴリズム名の一覧を持っています。この一覧は、名前と値の String ペアのマップです。さらに、newInstance() および supportsParameter() メソッドを定義します。これらのメソッドはデフォルトで実装されていますが、プロバイダがハードウェアセキュリティートークンとのインタフェースとなる場合は、必要に応じてプロバイダによるオーバーライドが可能です。

newInstance() メソッドは、新しい実装インスタンスを生成する必要がある場合に、セキュリティーフレームワークによって使用されます。デフォルトの実装では、リフレクションを使用してサービス各種の標準的なコンストラクタが呼び出されます。CertStore を除くすべての標準サービスで、このコンストラクタは引数をとりません。newInstance() の constructorParameter は、この場合 null である必要があります。CertStore 型のサービスでは、CertStoreParameters オブジェクトを使用するコンストラクタが呼び出されます。constructorParameter は、CertStoreParameters. の null 以外のインスタンスである必要があります。セキュリティープロバイダは、newInstance() メソッドをオーバーライドして、その実装に適したインスタンス化を実装できます。直接呼び出すことも、Provider インスタンスまたはトークンに固有の追加情報を渡すコンストラクタを呼び出すこともできます。たとえば、システムに複数のスマートカードリーダがある場合、新しく作成されたサービスをどのリーダーに関連付けるかという情報を渡すことができます。ただし、カスタマイズした場合でも、すべての実装は、前述の constructorParameter に関する規約に従わなければなりません。

supportsParameter() は、Service が指定されたパラメータを使用できるかどうかをテストします。このサービスがパラメータを使用できない場合、false を返します。このサービスがパラメータを使用できる場合、すばやいチェックが実行できない場合、またはステータスが不明な場合、true を返します。これは、ある種のサービスに対してセキュリティーフレームワークにより使用され、一致しない実装が対象からすばやく除外されます。現状では、これは Signature、Cipher、Mac、および KeyAgreement の標準サービスでのみ定義されています。この場合、parameter は Key のインスタンスである必要があります。たとえば、Signature サービスの場合、フレームワークはサービスをインスタンス化する前に、サービスが指定された Key を使用できるかどうかをテストします。デフォルトの実装では、前述のように、属性 SupportedKeyFormats および SupportedKeyClasses が検査されます。ここでも、プロバイダはこのメソッドをオーバーライドして、追加テストを実装できます。

SupportedKeyFormats 属性は、エンコードされた鍵 (key.getFormat() によって返される) でサポートされる形式の一覧で、「|」(パイプ) 文字で区切られています。たとえば、X.509|PKCS#8 です。SupportedKeyClasses 属性は、インタフェースまたはクラス名の一覧で、「|」文字で区切られています。鍵オブジェクトは、指定されたクラスまたはインタフェースの 1 つ以上に割り当て可能な場合に、受け入れ可能と認識されます。言い換えれば、鍵オブジェクトのクラスがリスト表示されたいずれかのクラスのサブクラス (またはクラス自体) である場合、またはリスト表示されたインタフェースを実装する場合です。たとえば、値 "java.security.interfaces.RSAPrivateKey|java.security.interfaces.RSAPublicKey" がこれに該当します。

サービスの追加および検索用の 4 つのメソッドが Provider クラスに追加されました。前述のように、これらのメソッドおよび既存の Properties メソッドの実装は、既存の Provider サブクラスとの互換性を保つように特別に設計されています。次のようにして実現されます。

既存の Properties メソッドをエントリの追加に使用する場合、Provider クラスは、プロパティー文字列を解析して等価な Service オブジェクトに変換してから、getService() を使用して検索するようにします。同様に、putService() メソッドを使用する場合、等価なプロパティー文字列がプロバイダのハッシュテーブルに同時に配置されます。プロバイダ実装が Provider クラス内のメソッドをオーバーライドする場合、実装がこの変換に干渉しないようにする必要があります。問題を防止するため、実装によって Provider クラスのメソッドがオーバーライドされないようにすることをお勧めします。

署名フォーマット

署名アルゴリズムを実装する場合、提供するドキュメント (ステップ 11) で署名 (sign メソッドの 1 つを使って生成される) をエンコードする形式を指定する必要があります。

たとえば、SUN プロバイダにより提供される SHA1withDSA 署名アルゴリズムは、署名を 2 つの ASN.1 INTEGER 値、r および s をこの順序で、標準 ASN.1 シーケンスとしてエンコードします。

SEQUENCE ::= {
        r INTEGER,
        s INTEGER }

DSA インタフェースおよびその実装要件

Java Security API には、DSA サービスを実装するプログラマが利用しやすいように、(java.security.interfaces パッケージ内の) 次のインタフェースが含まれます。

• DSAKey
• DSAKeyPairGenerator
• DSAParams
• DSAPrivateKey
• DSAPublicKey

以降のセクションでは、これらのインタフェースの実装要件について取り上げます。

DSAKeyPairGenerator 実装

このインタフェースは使用されていません。これは、クライアントに対し、実装で提供するデフォルトパラメータの代わりに DSA 固有のパラメータを使用することを可能にする上で必要でした。ただし、AlgorithmParameterSpec パラメータを取る新規 KeyPairGenerator initialize メソッドにより、クライアントがアルゴリズム固有のパラメータを示すことが可能になったため、Java ではこれは必要ではなくなりました。

DSAParams 実装

DSA 鍵ペアジェネレータを実装している場合、p、q、および g パラメータを保持したり返したりするために、DSAParams を実装するクラスを必要とします。

DSAPrivateKey および DSAPublicKey インタフェースを実装する場合は、DSAParams 実装も必要です。DSAPublicKey および DSAPrivateKey は、どちらも DSAParams オブジェクトを返す getParams メソッドを含む DSAKey インタフェースを拡張します。詳細は、「DSAPrivateKey および DSAPublicKey 実装」を参照してください。

注: JDK に組み込み済みの DSAParams 実装である java.security.spec.DSAParameterSpec クラスが存在します。

DSAPrivateKey および DSAPublicKey 実装

DSA 鍵ペアジェネレータまたは鍵ファクトリを実装する場合、DSAPrivateKey および DSAPublicKey インタフェースを実装するクラスを作成する必要があります。

DSA 鍵ペアジェネレータを実装する場合、(KeyPairGeneratorSpi サブクラスの) generateKeyPair メソッドはこれらのインタフェース実装のインスタンスを返します。

DSA 鍵ファクトリを実装する場合、(KeyFactorySpi サブクラスの) engineGeneratePrivate メソッドは DSAPrivateKey 実装のインスタンスを返し、engineGeneratePublic メソッドは DSAPublicKey 実装のインスタンスを返します。

また、engineGetKeySpec および engineTranslateKey メソッドは、引き渡される鍵が DSAPrivateKey または DSAPublicKey 実装のインスタンスであることを求めます。インタフェース実装により提供される getParams メソッドは、鍵からパラメータを取得および抽出し、そのあとパラメータを使用する上で有用です。たとえば、DSAParameterSpec コンストラクタへのパラメータとして使用して、DSA 用の KeyPairGenerator オブジェクトの初期化に使用可能なパラメータ値からパラメータ仕様を作成できます。

DSA 署名アルゴリズムを実装する場合、(SignatureSpi サブクラスの) engineInitSign メソッドは DSAPrivateKey が渡されることを期待し、engineInitVerify メソッドは DSAPublicKey が渡されることを期待します。

注: DSAPublicKey および DSAPrivateKey インタフェースはそれぞれ、DSA 公開鍵および非公開鍵に対するきわめて汎用的なプロバイダ非依存のインタフェースを定義します。KeyFactorySpi サブクラスの engineGetKeySpec メソッドと engineTranslateKey メソッドは、プロバイダ固有の実装の詳細を利用するなどの目的で、引き渡される鍵が実際にプロバイダ独自の DSAPrivateKey または DSAPublicKey 実装のインスタンスであるかどうかをチェックすることもできます。SignatureSpi サブクラスの DSA 署名アルゴリズム engineInitSign および engineInitVerify メソッドについても、同様のことが当てはまります。

DSAPublicKey および DSAPrivateKey インタフェースを実装するクラスを使用してどのようなメソッドを実装する必要があるかについては、次のインタフェース署名に注目してください。

java.security.interfaces パッケージ内:

   public interface DSAPrivateKey extends DSAKey,
                java.security.PrivateKey

   public interface DSAPublicKey extends DSAKey,
                java.security.PublicKey

   public interface DSAKey 

java.security パッケージ内:

   public interface PrivateKey extends Key

   public interface PublicKey extends Key

   public interface Key extends java.io.Serializable 

DSAPrivateKey インタフェースと DSAPublicKey インタフェースを実装するには、これらによって定義されるメソッドと、直接または間接的にこれらによって拡張されるインタフェースによって定義されたメソッドを実装する必要があります。

このため、非公開鍵の場合、次を実装するクラスを提供する必要があります

• DSAPrivateKey インタフェースの getX メソッド。
• java.security.interfaces.DSAKey インタフェースの getParams メソッド (DSAPrivateKey が DSAKey を拡張するため)。注:getParams メソッドは、DSAParams オブジェクトを返します。このため、DSAParams 実装も保持する必要があります。
• java.security.Key インタフェースの getAlgorithm、getEncoded、および getFormat メソッド (DSAPrivateKey が java.security.PrivateKey を拡張し、PrivateKey が Key を拡張するため)。

  同様に、公開 DSA 鍵の場合、次のものを実装するクラスを提供する必要があります。

  • DSAPublicKey インタフェースの getY メソッド。
  • java.security.interfaces.DSAKey インタフェースの getParams メソッド (DSAPublicKey が DSAKey を拡張するため)。注:getParams メソッドは、DSAParams オブジェクトを返します。このため、DSAParams 実装も保持する必要があります。
  • java.security.Key インタフェースの getAlgorithm、getEncoded、および getFormat メソッド (DSAPublicKey が java.security.PublicKey を拡張し、PublicKey が Key を拡張するため)。

RSA インタフェースおよびその実装要件

    public interface RSAPrivateKey extends java.security.PrivateKey

    public interface RSAPrivateCrtKey extends RSAPrivateKey

    public interface RSAPublicKey extends java.security.PublicKey

    public interface PrivateKey extends Key

    public interface PublicKey extends Key

    public interface Key extends java.io.Serializable

    public interface DHPrivateKey extends DHKey, java.security.PrivateKey

    public interface DHPublicKey extends DHKey, java.security.PublicKey

    public interface DHKey 

    public interface PrivateKey extends Key

    public interface PublicKey extends Key

    public interface Key extends java.io.Serializable 

    public BigInteger getP()

    public BigInteger getQ()

    public BigInteger getG()

    put("Alg.Alias.<engine_type>.1.2.3.4.5.6.7.8",
        "<algorithm_alias_name>");

    % keytool -genkeypair -sigalg 1.2.3.4.5.6.7.8

    put("Signature.Foo", "com.xyz.MyFooSignatureImpl");
    put("Alg.Alias.Signature.1.2.3.4.5.6.7.8", "Foo");

    put("KeyFactory.Foo", "com.xyz.MyFooKeyFactoryImpl");
    put("Alg.Alias.KeyFactory.1.2.3.4.5.6.7.8", "Foo");

    put("Alg.Alias.Signature.OID.1.2.3.4.5.6.7.8", "MySigAlg");

/*
 * @(#)Sun.java 1.28 99/05/27
 *
 * Copyright (c) 1996, 1998, Oracle and/or its affiliates. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 *   - Redistributions of source code must retain the above copyright
 *     notice, this list of conditions and the following disclaimer.
 *
 *   - Redistributions in binary form must reproduce the above copyright
 *     notice, this list of conditions and the following disclaimer in the
 *     documentation and/or other materials provided with the distribution.
 *
 *   - Neither the name of Oracle nor the names of its
 *     contributors may be used to endorse or promote products derived
 *     from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
 * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

package sun.security.provider;

import java.io.*;
import java.util.*;
import java.security.*;

/**
 * The SUN Security Provider.
 *
 * @author Benjamin Renaud
 *
 * @version 1.28, 05/27/99
 */

/**
 * Defines the SUN provider.
 *
 * Algorithms supported, and their names:
 *
 * - SHA is the message digest scheme described in FIPS 180-1.
 *   Aliases for SHA are SHA-1 and SHA1.
 *
 * - SHA1withDSA is the signature scheme described in FIPS 186.
 *   (SHA used in DSA is SHA-1: FIPS 186 with Change No 1.)
 *   Aliases for SHA1withDSA are DSA, DSS, SHA/DSA, SHA-1/DSA, SHA1/DSA,
 *   SHAwithDSA, DSAWithSHA1, and the object
 *   identifier strings "OID.1.3.14.3.2.13", "OID.1.3.14.3.2.27" and
 *   "OID.1.2.840.10040.4.3".
 *
 * - DSA is the key generation scheme as described in FIPS 186.
 *   Aliases for DSA include the OID strings "OID.1.3.14.3.2.12"
 *   and "OID.1.2.840.10040.4.1".
 *
 * - MD5 is the message digest scheme described in RFC 1321.
 *   There are no aliases for MD5.
 */

public final class Sun extends Provider {

    private static final String INFO = "SUN " +
    "(DSA key/parameter generation; DSA signing; " +
    "SHA-1, MD5 digests; SecureRandom; X.509 certificates; JKS keystore)";

    public Sun() {
        /* We are the SUN provider */
        super("SUN", 1.2, INFO);

        AccessController.doPrivileged(new java.security.PrivilegedAction() {
            public Object run() {

                /*
                 * Signature engines
                 */
                put("Signature.SHA1withDSA", "sun.security.provider.DSA");

                put("Alg.Alias.Signature.DSA", "SHA1withDSA");
                put("Alg.Alias.Signature.DSS", "SHA1withDSA");
                put("Alg.Alias.Signature.SHA/DSA", "SHA1withDSA");
                put("Alg.Alias.Signature.SHA-1/DSA", "SHA1withDSA");
                put("Alg.Alias.Signature.SHA1/DSA", "SHA1withDSA");
                put("Alg.Alias.Signature.SHAwithDSA", "SHA1withDSA");
                put("Alg.Alias.Signature.DSAWithSHA1", "SHA1withDSA");
                put("Alg.Alias.Signature.OID.1.2.840.10040.4.3",
                    "SHA1withDSA");
                put("Alg.Alias.Signature.1.2.840.10040.4.3", "SHA1withDSA");
                put("Alg.Alias.Signature.1.3.14.3.2.13", "SHA1withDSA");
                put("Alg.Alias.Signature.1.3.14.3.2.27", "SHA1withDSA");

                /*
                 *  Key Pair Generator engines
                 */
                put("KeyPairGenerator.DSA",
                    "sun.security.provider.DSAKeyPairGenerator");
                put("Alg.Alias.KeyPairGenerator.OID.1.2.840.10040.4.1", "DSA");
                put("Alg.Alias.KeyPairGenerator.1.2.840.10040.4.1", "DSA");
                put("Alg.Alias.KeyPairGenerator.1.3.14.3.2.12", "DSA");

                /*
                 * Digest engines
                 */
                put("MessageDigest.MD5", "sun.security.provider.MD5");
                put("MessageDigest.SHA", "sun.security.provider.SHA");

                put("Alg.Alias.MessageDigest.SHA-1", "SHA");
                put("Alg.Alias.MessageDigest.SHA1", "SHA");

                /*
                 * Algorithm Parameter Generator engines
                 */
                put("AlgorithmParameterGenerator.DSA",
                    "sun.security.provider.DSAParameterGenerator");

                /*
                 * Algorithm Parameter engines
                 */
                put("AlgorithmParameters.DSA",
                    "sun.security.provider.DSAParameters");
                put("Alg.Alias.AlgorithmParameters.1.3.14.3.2.12", "DSA");
                put("Alg.Alias.AlgorithmParameters.1.2.840.10040.4.1", "DSA");

                /*
                 * Key factories
                 */
                put("KeyFactory.DSA", "sun.security.provider.DSAKeyFactory");
                put("Alg.Alias.KeyFactory.1.3.14.3.2.12", "DSA");
                put("Alg.Alias.KeyFactory.1.2.840.10040.4.1", "DSA");

                /*
                 * SecureRandom
                 */
                 put("SecureRandom.SHA1PRNG",
                     "sun.security.provider.SecureRandom");

                /*
                 * Certificates
                 */
                put("CertificateFactory.X509",
                    "sun.security.provider.X509Factory");
                put("Alg.Alias.CertificateFactory.X.509", "X509");

                /*
                 * KeyStore
                 */
                put("KeyStore.JKS", "sun.security.provider.JavaKeyStore");

                /*
                 * KeySize
                 */
                put("Signature.SHA1withDSA KeySize", "1024");
                put("KeyPairGenerator.DSA KeySize", "1024");
                put("AlgorithmParameterGenerator.DSA KeySize", "1024");

                /*
                 * Implementation type: software or hardware
                 */
                put("Signature.SHA1withDSA ImplementedIn", "Software");
                put("KeyPairGenerator.DSA ImplementedIn", "Software");
                put("MessageDigest.MD5 ImplementedIn", "Software");
                put("MessageDigest.SHA ImplementedIn", "Software");
                put("AlgorithmParameterGenerator.DSA ImplementedIn",
                    "Software");
                put("AlgorithmParameters.DSA ImplementedIn", "Software");
                put("KeyFactory.DSA ImplementedIn", "Software");
                put("SecureRandom.SHA1PRNG ImplementedIn", "Software");
                put("CertificateFactory.X509 ImplementedIn", "Software");
                put("KeyStore.JKS ImplementedIn", "Software");

                return null;
            }
        });
    }
}

/*
 * @(#)SunJCE.java      1.73 05/12/13
 *
 * Copyright (c) 2006, Oracle and/or its affiliates. All rights reserved.
 * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
 */

package com.sun.crypto.provider;

import java.security.*;
import java.security.cert.*;
import java.net.URL;
import java.io.ByteArrayInputStream;

/**
 * The "SunJCE" Cryptographic Service Provider.
 *
 * @author Jan Luehe
 * @author Sharon Liu
 *
 * @version 1.73, 12/13/05
 */

/**
 * Defines the "SunJCE" provider.
 *
 * Supported algorithms and their names:
 *
 * ...edited for space...
 *
 */

public final class SunJCE extends Provider {

    private static final String info = "SunJCE Provider " +
    "(implements RSA, DES, Triple DES, AES, Blowfish, ARCFOUR, RC2, PBE, "
    + "Diffie-Hellman, HMAC)";

    private static final String OID_PKCS5_MD5_DES = "1.2.840.113549.1.5.3";
    private static final String OID_PKCS3 = "1.2.840.113549.1.3.1";

    public SunJCE() {
        /* We are the "SunJCE" provider */
        super("SunJCE", 1.6d, info);

        final String BLOCK_MODES = "ECB|CBC|PCBC|CTR|CTS|CFB|OFB" +
            "|CFB8|CFB16|CFB24|CFB32|CFB40|CFB48|CFB56|CFB64" +
            "|OFB8|OFB16|OFB24|OFB32|OFB40|OFB48|OFB56|OFB64";
        final String BLOCK_MODES128 = BLOCK_MODES +
            "|CFB72|CFB80|CFB88|CFB96|CFB104|CFB112|CFB120|CFB128" +
            "|OFB72|OFB80|OFB88|OFB96|OFB104|OFB112|OFB120|OFB128";
        final String BLOCK_PADS = "NOPADDING|PKCS5PADDING|ISO10126PADDING";

        AccessController.doPrivileged(new java.security.PrivilegedAction() {
                public Object run() {

                /*
                 * Cipher engines
                 */
                put("Cipher.RSA", "com.sun.crypto.provider.RSACipher");
                put("Cipher.RSA SupportedModes", "ECB");
                put("Cipher.RSA SupportedPaddings",
                        "NOPADDING|PKCS1PADDING|OAEPWITHMD5ANDMGF1PADDING"
                        + "|OAEPWITHSHA1ANDMGF1PADDING"
                        + "|OAEPWITHSHA-1ANDMGF1PADDING"
                        + "|OAEPWITHSHA-256ANDMGF1PADDING"
                        + "|OAEPWITHSHA-384ANDMGF1PADDING"
                        + "|OAEPWITHSHA-512ANDMGF1PADDING");
                put("Cipher.RSA SupportedKeyClasses",
                        "java.security.interfaces.RSAPublicKey" +
                        "|java.security.interfaces.RSAPrivateKey");

                put("Cipher.PBEWithMD5AndDES",
                    "com.sun.crypto.provider.PBEWithMD5AndDESCipher");
                put("Alg.Alias.Cipher.OID."+OID_PKCS5_MD5_DES,
                    "PBEWithMD5AndDES");
                put("Alg.Alias.Cipher."+OID_PKCS5_MD5_DES,
                    "PBEWithMD5AndDES");

                put("Cipher.AES", "com.sun.crypto.provider.AESCipher");
                put("Alg.Alias.Cipher.Rijndael", "AES");
                put("Cipher.AES SupportedModes", BLOCK_MODES128);
                put("Cipher.AES SupportedPaddings", BLOCK_PADS);
                put("Cipher.AES SupportedKeyFormats", "RAW");

                put("Cipher.AESWrap", "com.sun.crypto.provider.AESWrapCipher");
                put("Cipher.AESWrap SupportedModes", "ECB");
                put("Cipher.AESWrap SupportedPaddings", "NOPADDING");
                put("Cipher.AESWrap SupportedKeyFormats", "RAW");

                put("Cipher.ARCFOUR",
                    "com.sun.crypto.provider.ARCFOURCipher");
                put("Alg.Alias.Cipher.RC4", "ARCFOUR");
                put("Cipher.ARCFOUR SupportedModes", "ECB");
                put("Cipher.ARCFOUR SupportedPaddings", "NOPADDING");
                put("Cipher.ARCFOUR SupportedKeyFormats", "RAW");

                /*
                 *  Key(pair) Generator engines
                 */
                put("KeyGenerator.AES",
                    "com.sun.crypto.provider.AESKeyGenerator");
                put("Alg.Alias.KeyGenerator.Rijndael", "AES");

                put("KeyGenerator.ARCFOUR",
                    "com.sun.crypto.provider.KeyGeneratorCore$" +
                    "ARCFOURKeyGenerator");
                put("Alg.Alias.KeyGenerator.RC4", "ARCFOUR");

                put("KeyGenerator.HmacMD5",
                    "com.sun.crypto.provider.HmacMD5KeyGenerator");

                put("KeyGenerator.HmacSHA256",
                    "com.sun.crypto.provider.KeyGeneratorCore$HmacSHA256KG");

                put("KeyPairGenerator.DiffieHellman",
                    "com.sun.crypto.provider.DHKeyPairGenerator");
                put("Alg.Alias.KeyPairGenerator.DH", "DiffieHellman");
                put("Alg.Alias.KeyPairGenerator.OID."+OID_PKCS3,
                    "DiffieHellman");
                put("Alg.Alias.KeyPairGenerator."+OID_PKCS3,
                    "DiffieHellman");

                /*
                 * Algorithm parameter generation engines
                 */
                put("AlgorithmParameterGenerator.DiffieHellman",
                    "com.sun.crypto.provider.DHParameterGenerator");
                put("Alg.Alias.AlgorithmParameterGenerator.DH",
                    "DiffieHellman");
                put("Alg.Alias.AlgorithmParameterGenerator.OID."+OID_PKCS3,
                    "DiffieHellman");
                put("Alg.Alias.AlgorithmParameterGenerator."+OID_PKCS3,
                    "DiffieHellman");

                /*
                 * Key Agreement engines
                 */
                put("KeyAgreement.DiffieHellman",
                    "com.sun.crypto.provider.DHKeyAgreement");
                put("Alg.Alias.KeyAgreement.DH", "DiffieHellman");
                put("Alg.Alias.KeyAgreement.OID."+OID_PKCS3, "DiffieHellman");
                put("Alg.Alias.KeyAgreement."+OID_PKCS3, "DiffieHellman");

                put("KeyAgreement.DiffieHellman SupportedKeyClasses",
                    "javax.crypto.interfaces.DHPublicKey" +
                    "|javax.crypto.interfaces.DHPrivateKey");

                /*
                 * Algorithm Parameter engines
                 */
                put("AlgorithmParameters.DiffieHellman",
                    "com.sun.crypto.provider.DHParameters");
                put("Alg.Alias.AlgorithmParameters.DH", "DiffieHellman");
                put("Alg.Alias.AlgorithmParameters.OID."+OID_PKCS3,
                    "DiffieHellman");
                put("Alg.Alias.AlgorithmParameters."+OID_PKCS3,
                    "DiffieHellman");

                put("AlgorithmParameters.PBEWithMD5AndDES",
                    "com.sun.crypto.provider.PBEParameters");
                put("Alg.Alias.AlgorithmParameters.OID."+OID_PKCS5_MD5_DES,
                    "PBEWithMD5AndDES");
                put("Alg.Alias.AlgorithmParameters."+OID_PKCS5_MD5_DES,
                    "PBEWithMD5AndDES");

                put("AlgorithmParameters.OAEP",
                    "com.sun.crypto.provider.OAEPParameters");

                /*
                 * Key factories
                 */
                put("KeyFactory.DiffieHellman",
                    "com.sun.crypto.provider.DHKeyFactory");
                put("Alg.Alias.KeyFactory.DH", "DiffieHellman");
                put("Alg.Alias.KeyFactory.OID."+OID_PKCS3,
                    "DiffieHellman");
                put("Alg.Alias.KeyFactory."+OID_PKCS3, "DiffieHellman");

                /*
                 * Secret-key factories
                 */
                put("SecretKeyFactory.PBEWithMD5AndDES",
                    "com.sun.crypto.provider.PBEKeyFactory$PBEWithMD5AndDES"
                    );
                put("Alg.Alias.SecretKeyFactory.OID."+OID_PKCS5_MD5_DES,
                    "PBEWithMD5AndDES");
                put("Alg.Alias.SecretKeyFactory."+OID_PKCS5_MD5_DES,
                    "PBEWithMD5AndDES");

                /*
                 * MAC
                 */
                put("Mac.HmacMD5", "com.sun.crypto.provider.HmacMD5");
                put("Mac.HmacSHA256",
                    "com.sun.crypto.provider.HmacCore$HmacSHA256");

                put("Mac.HmacMD5 SupportedKeyFormats", "RAW");
                put("Mac.HmacSHA256 SupportedKeyFormats", "RAW");

                /*
                 * KeyStore
                 */
                put("KeyStore.JCEKS", "com.sun.crypto.provider.JceKeyStore");

                return null;
            }
        });
    }
}
 

<java-home>/lib/security/java.security     [Solaris]
<java-home>\lib\security\java.security     [Win32]

#
# This is the "master security properties file".
#
# In this file, various security properties are set for use by
# java.security classes. This is where users can statically register
# Cryptography Package Providers ("providers" for short). The term
# "provider" refers to a package or set of packages that supply a
# concrete implementation of a subset of the cryptography aspects of
# the Java Security API. A provider may, for example, implement one or
# more digital signature algorithms or message digest algorithms.
#
# Each provider must implement a subclass of the Provider class.
# To register a provider in this master security properties file,
# specify the Provider subclass name and priority in the format
#
#    security.provider.<n>=<className>
#
# This declares a provider, and specifies its preference
# order n. The preference order is the order in which providers are
# searched for requested algorithms (when no specific provider is
# requested). The order is 1-based; 1 is the most preferred, followed
# by 2, and so on.
#
# <className> must specify the subclass of the Provider class whose
# constructor sets the values of various properties that are required
# for the Java Security API to look up the algorithms or other
# facilities implemented by the provider.
#
# There must be at least one provider specification in java.security.
# There is a default provider that comes standard with the JDK. It
# is called the "SUN" provider, and its Provider subclass
# named Sun appears in the sun.security.provider package. Thus, the
# "SUN" provider is registered via the following:
#
#    security.provider.1=sun.security.provider.Sun
#
# (The number 1 is used for the default provider.)
#
# Note: Providers can be dynamically registered instead by calls to
# either the addProvider or insertProviderAt method in the Security
# class.

#
# List of providers and their preference orders (see above):
#

security.provider.1=sun.security.pkcs11.SunPKCS11 \
    ${java.home}/lib/security/sunpkcs11-solaris.cfg
security.provider.2=sun.security.provider.Sun
security.provider.3=sun.security.rsa.SunRsaSign
security.provider.4=com.sun.net.ssl.internal.ssl.Provider
security.provider.5=com.sun.crypto.provider.SunJCE
security.provider.6=sun.security.jgss.SunProvider
security.provider.7=com.sun.security.sasl.Provider
security.provider.8=org.jcp.xml.dsig.internal.dom.XMLDSigRI
security.provider.9=sun.security.smartcardio.SunPCSC

# Rest of file deleted