JavaTM 2 Platform Standard Edition Development Kit (JDK) でのアクセス権



アクセス権は、システムリソースへのアクセスを表します。アプレット (またはセキュリティマネージャとともに実行するアプリケーション) が、リソースへのアクセスを許可されるためには、アクセスを試みるコードに対し、該当するアクセス権を明示的に与える必要があります。

一般に、アクセス権は名前 (しばしば「ターゲット名」と呼ばれる) を持っています。場合によっては、名前のほかに、コンマで区切られた 1 つ以上のアクションのリストを持つこともあります。たとえば、次のコードでは、/tmp ディレクトリの abc という名前のファイルへの読み取りアクセスを表す FilePermission オブジェクトを作成します。

perm = new java.io.FilePermission("/tmp/abc", "read");

この場合、ターゲット名が "/tmp/abc" で、アクション文字列が "read" になります。

重要: 上記の文によって、アクセス権オブジェクトが作成されます。アクセス権オブジェクトは、システム資源を表しますが、システム資源へのアクセスを許可することはありません。アクセス権オブジェクトは、実効性のあるポリシーに基づいて作成され、コードへ割り当てられ (許可され) ます。アクセス権オブジェクトがあるコードに割り当てられると、そのコードはアクセス権オブジェクトにより指定されたシステム資源へ、指定された方法でアクセスすることが許可されます。現在のセキュリティマネージャが、アクセス判断を行う際に、アクセス権オブジェクトを作成することもあります。この場合、ターゲットのアクセス権オブジェクトは、要求されたアクセスに基づいて作成されます。さらに、ターゲットのアクセス権オブジェクトは、要求を行うコードに許可され、かつ要求を行うコードが保持する、アクセス権オブジェクトに照らしてチェックされます。

Java アプリケーション環境のポリシーは、Policy オブジェクトにより表現されます。Policy のリファレンス実装では、1 つまたは複数のポリシー構成ファイルからポリシーを指定できます。ポリシーファイルは、指定したコードソースのコードにどのアクセス権を許可するかを指定します。たとえば、/home/sysadmin ディレクトリのコードに対し、/tmp/abc ファイルへの読み取りアクセスを許可する場合、ポリシーファイルのエントリは、次のようになります。

grant codeBase "file:/home/sysadmin/" {
permission java.io.FilePermission "/tmp/abc", "read";
};

ポリシーファイルの場所、およびポリシーファイルにより許可するアクセス権の詳細については、「デフォルトの Policy の実装とポリシーファイルの構文」を参照してください。Policy Tool を使ってアクセス権を指定する方法については、Policy Tool のドキュメント (Solaris 版) (Windows 版) を参照してください。Policy Tool を使うと、入力やポリシーファイルの構文規則を記憶する手間を減らすことができます。

技術的な観点から言うと、リソースへのアクセスを試みる場合は、実行スレッド上のコードに「特権設定」のマークが付けられていないかぎり、実行スレッドが利用するコードは「すべて」、そのリソースへのアクセス権を保持する必要があります。特権の設定されたコードの詳細については、「特権ブロックのための API」 を参照してください。

このドキュメントでは、JDK に組み込みのアクセス権型を示すとともに、それぞれのアクセス権を与えた場合のリスクについて説明します。また、呼び出しにアクセス権を必要とするメソッドと、それぞれのメソッドが必要とするアクセス権の一覧も示します。

説明する内容は次のとおりです。

アクセス権の説明とリスク
java.security.AllPermission
java.security.SecurityPermission
java.security.UnresolvedPermission
java.awt.AWTPermission
java.io.FilePermission
java.io.SerializablePermission
java.lang.reflect.ReflectPermission
java.lang.RuntimePermission
  • NIO 関連ターゲット
    • java.net.NetPermission
    java.net.SocketPermission
    java.sql.SQLPermission
    java.util.PropertyPermission
    java.util.logging.LoggingPermission
    javax.net.ssl.SSLPermission
    javax.security.auth.AuthPermission
    javax.security.auth.PrivateCredentialPermission
    javax.security.auth.kerberos.DelegationPermission
    javax.security.auth.kerberos.ServicePermission
    javax.sound.sampled.AudioPermission


    メソッドとその呼び出しに必要なアクセス権

    java.lang.SecurityManager のメソッドとその呼び出しに必要なアクセス権


    アクセス権や、スーパークラス java.security.Permission および java.security.BasicPermission についての詳細と、アクセス権オブジェクトの作成およびアクセス権の設定の例については、セキュリティアーキテクチャの仕様を参照してください。

    アクセス権の説明とリスク

    ここでは、JDK に組み込みのアクセス権型の一覧表を示すとともに、それぞれのアクセス権を与えた場合のリスクについて説明します。

    AllPermission

    java.security.AllPermission は、すべてのアクセス権を意味するアクセス権です。

    注: AllPermission を付与すると、すべてのアクセス権を付与することになりますので十分に注意してください。このアクセス権を指定すると、コードはセキュリティ無効の状態で実行されるようになります。このようなアクセス権をコードに与えるときは、十分な注意を払ってください。このアクセス権は、テスト時か、アプリケーションまたはアプレットが完全に信頼できる場合で、なおかつ必要なアクセス権をポリシーに追加するのが非常に煩雑な作業になるような、極めてまれなケースでだけ使用するようにしてください。

    SecurityPermission

    java.security.SecurityPermission は、セキュリティアクセス権を表します。SecurityPermission には名前 (ターゲット名とも呼ばれる) は含まれますが、アクションリストは含まれません。したがって、名前付きアクセス権を指定するか、指定しないかのどちらかになります。

    ターゲット名には、セキュリティ構成パラメータの名前 (下記を参照) を指定します。現在のところ、SecurityPermission オブジェクトは、Policy、Security、Provider、Signer、および Identity オブジェクトへのアクセスの保護に使用されます。

    SecurityPermission に指定できるターゲット名と、それで与えられるアクセス権により可能になる操作、およびそのアクセス権をコードに与えることにより生じるリスクを次の表に示します。

    java.security.SecurityPermission
    のターゲット名    		 可能になる操作 このアクセス権を与えた場合のリスク
    createAccessControlContext AccessControlContext の作成 これにより、DomainCombiner を使って AccessControlContext をインスタンス化できる。現在スタックにある ProtectionDomain へのリファレンスが DomainCombiner に与えられるため、悪意のある DomainCombiner である場合、プライバシーが漏出する危険性がある
    getDomainCombiner AccessControlContext の DomainCombiner を取得 特定の CodeSource に対してどのようなアクセス権が与えられているかを知ることができる getPermissions の呼び出しにより、システム全体のセキュリティポリシーに対して問い合わせができるようになる。ポリシー情報が盗まれてもシステムのセキュリティが脅かされるわけではないが、攻撃の狙いをより正確に定めるための追加情報を悪意のあるコードに与えてしまう。必要以上の情報は公開しないようにする必要がある
    getPolicy システム全体のセキュリティポリシー (具体的には、現在インストールされている Policy オブジェクト) の取得 特定の CodeSource に対してどのようなアクセス権が与えられているかを知ることができる getPermissions の呼び出しにより、システム全体のセキュリティポリシーに対して問い合わせができるようになる。ポリシー情報が盗まれてもシステムのセキュリティが脅かされるわけではないが、攻撃の狙いをより正確に定めるための追加情報を悪意のあるコードに与えてしまう。必要以上の情報は公開しないようにする必要がある
    setPolicy システム全体のセキュリティポリシー (具体的には、Policy オブジェクト) の設定 このアクセス権を与えると、悪意のあるコードは、システムを攻撃するのに必要なアクセス権のすべてを自らに与えることができるようになるため、きわめて危険である
    getProperty.{key} 鍵を指定してのセキュリティプロパティの取得 指定した鍵により可能になるアクセスの種類によっては、コードから、システム全体のポリシーとユーザセキュリティポリシーの場所のほか、セキュリティプロバイダのリストにもアクセスできるようになる。この情報が盗まれてもシステムのセキュリティが脅かされるわけではないが、攻撃の狙いをより正確に定めるための追加情報を悪意のあるコードに与えてしまう
    setProperty.{key} 鍵を指定してのセキュリティプロパティの設定 これには、セキュリティプロバイダの設定と、システム全体のセキュリティポリシーの場所の定義が含まれる。新しいセキュリティプロバイダを設定するアクセス権が与えられた悪意のあるコードは、暗号化非公開鍵などの機密情報を盗むプロバイダを設定する可能性がある。また、システム全体のセキュリティポリシーの場所を設定するアクセス権が与えられた悪意のあるコードは、システムを攻撃するのに必要なアクセス権のすべてを攻撃者に与えるセキュリティポリシーの場所をその場所に設定する可能性がある
    insertProvider.{provider name} 指定した新しいプロバイダの追加 悪意のあるプロバイダ (受け取った非公開鍵を暴露するプロバイダなど) を、もっとも高い優先順位を持つプロバイダとして追加できるようになる。これは、インストールされているプロバイダを管理する現在の Security オブジェクトは、プロバイダを追加する前に、その完全性や信頼性のチェックは行わないためである
    removeProvider.{provider name} 指定したプロバイダの削除 プログラムの他の部分の動作を変更したり、その実行を無効にすることができるようになる。プログラムが要求したプロバイダがすでに削除されてしまった場合、実行が異常終了する可能性がある。また、削除されたプロバイダがプログラムの残りの部分で要求されていなくても、そのプロバイダが、通常、暗号化サービスが要求されたときに選ばれるプロバイダである場合は (プロバイダのリストで前の方にあるため)、代わりに別のプロバイダが選ばれるか、適切なプロバイダが見つからない場合はエラーになる
    setSystemScope システムのアイデンティティスコープの設定 攻撃者は、信頼されるべきでない証明書を使用してシステムのアイデンティティスコープを設定し、そのような証明書を使用して署名されたアプレットやアプリケーションのコードに、システムの元のアイデンティティスコープでは拒否されていた特権を与えることができる
    setIdentityPublicKey Identity の公開鍵の設定 アイデンティティが「信頼できるもの」としてマークされている場合、攻撃者は、システムのアイデンティティスコープが信頼していない別の公開鍵 (独自の公開鍵など) を設定し、その公開鍵を使用して署名されたアプレットやアプリケーションのコードに、本来なら否定されていた特権を与えることができる
    setIdentityInfo Identity の概要を表す文字列の設定 攻撃者は、アイデンティティの概要を表す文字列を設定できるようになる。これにより攻撃者は、アプリケーションを騙して目的のものとは異なるアイデンティティを使用させるようにしたり、特定のアイデンティティを見つけることができないようにしたりできる
    addIdentityCertificate Identity の証明書の追加 攻撃者は、アイデンティティの公開鍵に証明書を設定できるようになる。システム全体の信頼関係に影響するため、このアクセス権は危険である。この公開鍵は、本来よりも広い範囲のコードに対して急に信頼性を持つようになる
    removeIdentityCertificate Identity の証明書の削除 攻撃者は、アイデンティティの公開鍵のための証明書を削除できるようになる。システム全体の信頼関係に影響するため、このアクセス権は危険である。この公開鍵は、急に本来よりも信頼性が低く見なされるようになる
    printIdentity 主体の名前、および必要に応じ主体が使用されるスコープを表示する。また、主体がそのスコープで「信頼されている」と見なされるかどうかも示す 出力されるスコープがファイル名の場合、ローカルシステムの情報が伝達されてしまうことがある。例として、「carol」という名前のアイデンティティのサンプル出力を示す。「carol」は、ユーザのアイデンティティデータベースでは「信頼されない」としてマーク付けされている
    carol[/home/luehe/identitydb.obj][not trusted]
    clearProviderProperties.{provider name} プロバイダにより実装されているサービスの参照に使用されるプロパティが空になるように、Provider を「クリア」する プロバイダによって実装されているサービスの参照が無効になる。したがって、アクセス権「removeProvider.{provider name}」の部分で説明しているように、通常はその Provider を利用しているプログラムの他の部分の動作が変更されたり、その実行が無効になったりする可能性がある
    putProviderProperty.{provider name} 指定した Provider のプロパティの設定 プロバイダのプロパティは、そのプロバイダによって実装されている特定のサービスの名前と場所を指定する。このアクセス権を与えると、コードからサービスの指定を変更し、別の実装を指定できるようになる。
    removeProviderProperty.{provider name} 指定した Provider からのプロパティの削除 プロバイダによって実装されているサービスの参照が無効になる。プロバイダの名前と場所を指定したプロパティが削除されるため、そのプロバイダにはアクセスできなくなる。したがって、アクセス権「removeProvider.{provider name}」の部分で説明しているように、通常はその Provider を利用しているプログラムの他の部分の動作が変更されたり、その実行が無効になったりする可能性がある
    getSignerPrivateKey 署名者の非公開鍵の取得 非公開鍵へのアクセスを許可するのは非常に危険である。非公開鍵は、ほかに知られないようにしておくことが前提になっている。非公開鍵が知られてしまうと、コードはその非公開鍵を使用してさまざまなファイルに署名し、署名がその署名者のものであると主張できるようになる
    setSignerKeyPair 署名者の鍵のペア (公開鍵と非公開鍵) の設定 攻撃者は、他人 (ターゲット) の鍵のペアを、それよりも弱い鍵のペア (たとえば、キーサイズの小さいもの) などと置き換えることができるようになる。また、標的とその通信相手との間の暗号化されたやりとりを傍受できるようにもなる。ターゲットの通信相手が、ターゲットの「新しい」公開鍵を使用して暗号化セッション鍵をラップしても、攻撃者 (対応する非公開鍵の所有者) は、「新しい」公開鍵を使用してそのセッション鍵のラップを解除し、そのセッション鍵を使用して暗号化された通信データを解読できる

    UnresolvedPermission

    java.security.UnresolvedPermission クラスは、ポリシーが初期化されたときに「未解決」になっているアクセス権を保持するために使用されます。未解決のアクセス権とは、ポリシーが初期化 (以下を参照) されたときに、実際に使用する Permission クラスがまだ存在していないアクセス権です。

    Java Runtime のポリシーは、さまざまな主体を出所とするコードがどのようなアクセス権を使用できるかを指定するもので、Policy オブジェクトによって表されます。ポリシーが初期化または更新されるたびに、そのポリシーによって許可されるすべてのアクセス権に対して、適切なクラスの Permission オブジェクトが作成されます。

    ポリシーの構成によって参照されるアクセス権クラスタイプの多くは、ローカルに存在します (つまり、CLASSPATH 上に置かれている)。それらのアクセス権のオブジェクトは、ポリシーの初期化中にインスタンス化できます。たとえば、FilePermission クラスは、CLASSPATH 上にあるため、java.io.FilePermission はいつでもインスタンス化できます。

    これに対し、ポリシーの初期化時にはまだ存在していないアクセス権クラスもあります。たとえば、参照されたアクセス権クラスは、あとにロードされる JAR ファイル内にある可能性があります。そのような各クラスに対しては、UnresolvedPermission がインスタンス化されます。つまり、UnresolvedPermission は、基本的にアクセス権に関する情報を含む「プレースホルダ」です。

    あとで、コードが未解決タイプのアクセス権に関する AccessController.checkPermission を呼び出したときに、そのアクセス権のクラスがすでにロードされている場合は、その未解決タイプのアクセス権が「解決」されます。つまり、各 UnresolvedPermission について、UnresolvedPermission 内の情報に基づいて適切なクラスタイプの新規オブジェクトのインスタンスが生成されます。この新規オブジェクトが UnresolvedPermission に置き換わり、UnresolvedPermission は削除されます。

    AWTPermission

    java.awt.AWTPermission は、AWT のアクセス権を表します。

    AWTPermission に指定できるターゲット名と、それで与えられるアクセス権により可能になる操作、およびそのアクセス権をコードに与えた場合のリスクを次の表に示します。

    java.awt.AWTPermission
    のターゲット名    		 可能になる操作 このアクセス権を与えた場合のリスク
    accessClipboard AWT のクリップボードへの情報のポストと、AWT のクリップボードからの情報の取得 これにより、慎重な取り扱いが必要な情報や機密情報が、悪意のあるコードによって共有される可能性がある
    accessEventQueue AWT のイベントキューへのアクセス 悪意のあるコードが、AWT のイベントキューを取得したあと、システムのイベントを覗いたり削除したりする可能性があるほか、アプリケーションやアプレットが不正な振る舞いをするような偽のイベントをポストする可能性がある
    createRobot java.awt.Robot オブジェクトの作成 java.awt.Robot オブジェクトは、コードでネイティブレベルのマウスとキーボードイベントを生成し、画面を読み取ることができる。悪意のあるコードによってシステムの管理、プログラムの実行、画面の読み取りを行い、ユーザがマウスとキーボードを使用できないようにすることができる
    listenToAllAWTEvents システム全体に渡り、すべての AWT イベントを待機 AWT イベントリスナーの追加後、悪質なコードがシステム内でディスパッチされたすべての AWT イベントを走査し、パスワードを含むユーザの入力をすべて読み取ろうとする可能性がある。各 AWT イベントリスナーは、そのイベントキューの EventDispatchThread のコンテキスト内から呼び出されるため、accessEventQueue 権限が有効な場合、悪質なコードが AWT イベントキューの内容をシステム全体に渡って変更し、アプリケーションまたはアプレットを安全でない方法で誤動作させる可能性がある
    readDisplayPixels 表示画面からピクセルを読み出す 任意のコードに表示画面のピクセルを検査することを許可する java.awt.Composite インタフェースなどのインタフェースにより、悪質なコードがユーザの活動を覗き見るのを許可してしまう可能性がある
    showWindowWithoutWarningBanner アプレットによって作成されたことを示す警告バナーを表示せずに、ウィンドウだけを表示 この警告が表示されないと、アプレットがウィンドウを表示しても、そのウィンドウがアプレットに属することがユーザに認識されない。ユーザは、ウィンドウがアプレットに属しているかどうかによって、セキュリティにかかわる決定をする場合があるため (ユーザ名とパスワードをダイアログボックスに入力するなど)、この警告バナーを無効にすると、アプレットは、ユーザを騙してユーザにこのような情報を入力させることができるようになる

    FilePermission

    java.io.FilePermission は、ファイルまたはディレクトリへのアクセスを表します。FilePermission は、パス名と、そのパス名に対して有効なアクションの集合から成ります。

    パス名には、指定したアクションを許可するファイルまたはディレクトリのパス名を指定します。「/*」(「/」はファイル区切り文字 File.separatorChar) で終わるパス名は、ディレクトリと、そのディレクトリに含まれるすべてのファイルを表します。「/-」で終わるパス名は、ディレクトリと、そのディレクトリに含まれるすべてのファイルとサブディレクトリ (再帰的に) を表します。パス名に特殊なトークン「<<ALL FILES>>」を指定した場合は、すべてのファイルに一致します。

    「*」が 1 つだけ指定されたパス名は、現在のディレクトリ内のすべてのファイルを表し、「-」が 1 つだけ指定されたパス名は、現在のディレクトリ内のすべてのファイルと、現在のディレクトリに含まれるすべてのファイルとサブディレクトリ (再帰的に) を表します。

    許可するアクションは、コンマで区切られた 0 個以上のキーワードのリストを内容とする文字列としてコンストラクタに引き渡されます。有効なキーワードは、「read」、「write」、「execute」、および「delete」です。それぞれの意味は、次のように定義されます。

    read 読み取り権
    write 書き込み権 (作成権も含む)
    execute 実行権。Runtime.exec を呼び出せるようになる。SecurityManager.checkExec に対応
    delete 削除権。File.delete を呼び出せるようになる。SecurityManager.checkDelete に対応

    アクション文字列は、処理される前に小文字に変換されます。

    FilePermission を許可する場合には注意してください。さまざまなファイルやディレクトリへの読み取りアクセス、特に書き込みアクセスを許可するとどうなるかをよく検討してください。write アクションに対して「<<ALL FILES>>」を指定するのは特に危険です。これは、ファイルシステム全体に対する書き込みを許可するということです。このような指定をすると、事実上、JVM 実行環境を含め、システムバイナリを置き換えることが可能になってしまいます。

    注: コードは同一ディレクトリ (またはそのディレクトリのサブディレクトリ) 内のファイルを常に読み取ることができるので、読み取り時のアクセス権を明示する必要はありません。

    SerializablePermission

    java.io.SerializablePermission は、直列化可能アクセス権を表します。SerializablePermission には名前 (ターゲット名とも呼ばれる) は含まれますが、アクションリストは含まれません。したがって、名前付きアクセス権を指定するか、指定しないかのどちらかになります。

    ターゲット名には、直列化可能アクセス権 (下記を参照) の名前を指定します。

    SerializablePermission に指定できるターゲット名と、それで与えられるアクセス権により可能になる操作、およびそのアクセス権をコードに与えることにより生じるリスクを次の表に示します。

    java.io.SerializablePermission
    のターゲット名    		 可能になる操作 このアクセス権を与えた場合のリスク
    enableSubclassImplementation ObjectOutputStream または ObjectInputStream のサブクラスを実装し、オブジェクトのデフォルトの直列化または直列化復元をオーバーライドする コードはこれを利用し、悪意を持ってクラスの直列化や直列化復元を行う可能性がある。たとえば、直列化中、非常に重要な private フィールドデータを、攻撃者が簡単にアクセスできる形で保存する可能性がある。また、直列化復元中、クラスの private フィールドをすべてゼロにして直列化復元する可能性がある
    enableSubstitution 直列化または直列化復元中、オブジェクトを別のオブジェクトと入れ替える 悪意のあるコードが、オブジェクトを、不正なデータが含まれたオブジェクトと差し替える可能性があるため、このアクセス権は危険である

    ReflectPermission

    java.lang.reflect.ReflectPermission は、リフレクション操作に対するアクセス権を表します。ReflectPermission は「名前付きアクセス権」であり、アクションはとりません。現時点で定義されている名前は suppressAccessChecks だけです。この名前を指定すると、リフレクトされたオブジェクトによってその使用時点で実行される、標準の言語アクセスチェック (public、デフォルト (パッケージ) アクセス、protected、および private なメンバが対象) が抑止されます。

    このアクセス権により可能になる操作と、このアクセス権をコードに与えることにより生じるリスクを次の表に示します。

    java.lang.reflect.ReflectPermission
    のターゲット名    		 可能になる操作 このアクセス権を与えた場合のリスク
    suppressAccessChecks 警告: このアクセス権をコードに与えるときは、十分な注意を払う必要がある。このアクセス権により、特定のクラスのフィールドへのアクセスと、メソッドの呼び出しが可能になる。public のほか、protected、private などのフィールドおよびメソッドも含まれる 悪意のあるコードが、通常は利用できない情報 (機密情報など) およびメソッドにアクセスできるようになってしまうため、このアクセス権は危険である

    RuntimePermission

    java.lang.RuntimePermission は、実行時アクセス権を表します。RuntimePermission には名前 (ターゲット名とも呼ばれる) は含まれますが、アクションリストは含まれません。したがって、名前付きアクセス権を指定するか、指定しないかのどちらかになります。

    ターゲット名には、実行時アクセス権 (下を参照) の名前を指定します。命名規約は、階層的なプロパティ命名規約に従います。また、ターゲット名のあとにアスタリスクを指定し (「.」のあとに指定するか、単独で指定)、ワイルドカードによる照合を行うこともできます。たとえば、「loadLibrary.*」や「*」は有効ですが、「*loadLibrary」や「a*b」は無効です。

    RuntimePermission に指定できるターゲット名と、それで与えられるアクセス権により可能になる操作、および、そのアクセス権をコードに与えることにより生じるリスクを次の表に示します。

    java.lang.RuntimePermission
    のターゲット名    		 可能になる操作 このアクセス権を与えた場合のリスク
    createClassLoader クラスローダの作成 このアクセス権を与えるのはきわめて危険である。悪意のあるアプリケーションが独自のクラスローダのインスタンスを生成し、破壊行為を行うクラスをシステムにロードする可能性がある。この新たにロードされたクラスが同じクラスローダによって保護ドメインに置かれ、ロードされたクラスに、そのドメインのアクセス権が自動的に与えられる可能性がある
    getClassLoader クラスローダ (呼び出し側クラスのクラスローダなど) の取得 これにより、特定のクラスのクラスローダを取得するためのアクセス権を、攻撃者に与えることになる。あるクラスのクラスローダにアクセスできると、攻撃者は、そのクラスローダから使用できるほかのクラスをロードできるようになるため、このアクセス権は危険である。本来は、そのようなクラスにはアクセスすることはできない
    setContextClassLoader 特定のスレッドによって使用されるコンテキストクラスローダの設定 コンテキストクラスローダは、システムクラスローダに存在しない可能性のあるリソースを探す必要があるときに、システムコードおよびエクステンションによって使用される。setContextClassLoader アクセス権を与えると、コードは、システムスレッドを含め、特定のスレッドで使用するコンテキストクラスローダを変更できるようになる
    setSecurityManager セキュリティマネージャの設定 (既存のセキュリティマネージャの差し替えも含む) セキュリティマネージャとは、アプリケーションがセキュリティポリシーを実装できるクラスである。setSecurityManager アクセス権を与えると、コードは、別のセキュリティマネージャ (より制限の少ないセキュリティマネージャなど) をロードし、使用するセキュリティマネージャを変更できるようになる。この結果、元のセキュリティマネージャによって課されていたチェックを回避できるようになる
    createSecurityManager 新しいセキュリティマネージャの作成 これにより、コードは、ほかのクラスまたは実行スタックに関する情報を開示してしまうような、保護された、慎重に取り扱われるべきメソッドにアクセスできるようになる
    exitVM Java 仮想マシンの停止 攻撃者は、Java 仮想マシンを自動的に強制停止させるサービス妨害攻撃をしかけることができるようになる
    shutdownHooks Java 仮想マシンのシャットダウンフックの登録および解除 攻撃者は悪意のあるシャットダウンフックを登録し、Java 仮想マシンのクリーンなシャットダウンを変更できるようになる
    setFactory ServerSocket または Socket により使用されるソケットファクトリ、または URL により使用されるストリームハンドラファクトリの設定 これにより、コードから、ソケット、サーバソケット、ストリームハンドラ、または RMI ソケットファクトリの実際の実装を設定できるようになる。攻撃者は、データストリームを狂わせる異常な実装を設定する可能性がある
    setIO System.out、System.in、および System.err の設定 標準システムストリームの値を変更できるようになる。攻撃者は、ユーザの入力を監視し、それを盗めるように System.in を改変したり、System.err に送られるエラーメッセージが出力されないように System.err を null OutputSteam に設定したりする可能性がある
    modifyThread stop、suspend、resume、setPriority、および setName メソッド 攻撃者は、システム内のどのスレッドでも開始または一時停止ができるようになる
    stopThread Thread の stop メソッドの呼び出しによるスレッドの停止 スレッドへのアクセス権をすでに取得している場合、コードから、システム内のどのスレッドでも停止できるようになる。実行中のスレッドが終了させられ、システムが破壊される可能性がある
    modifyThreadGroup スレッドグループの作成または変更 (スレッドの作成中にスレッドをスレッドグループに追加するか、または ThreadGroup の destroy、resume、setDaemon、setMaxPriority、stop、および suspend メソッドを呼び出すことによる) 攻撃者は、スレッドグループ内のスレッドの作成や、スレッドグループの作成や変更 (実行の優先順位の設定など) が可能になる
    getProtectionDomain 特定のクラスの ProtectionDomain の取得 コードから、特定のコードソースのポリシー情報を取得できるようになる。ポリシー情報が盗まれてもシステムのセキュリティが脅かされるわけではないが、攻撃の狙いをより正確に定めるためのローカルファイル名などの追加情報を攻撃者に与えてしまうことになる
    readFileDescriptor ファイル記述子の読み出し コードから、読み出したファイル記述子に関連付けられているファイルを読み出すことができるようになる。ファイルに機密データが含まれている場合、このアクセス権は危険である
    writeFileDescriptor ファイル記述子への書き込み コードから、そのファイル記述子に関連付けられているファイルに書き込めるようになる。悪意のあるコードにより、ウイルスが仕掛けられたり、ディスクをいっぱいにされたりする可能性があるため、このアクセス権は危険である
    loadLibrary.{library name} 指定したライブラリの動的なリンク Java のセキュリティアーキテクチャは、ネイティブコードレベルでの悪意のある振る舞いを阻止することができず、そのようには設計されていない。このため、ネイティブコードライブラリのロード許可をアプレットに与えるのは危険である
    accessClassInPackage.
    {package name}    		 クラスローダがセキュリティマネージャの checkPackageAcesss メソッドを呼び出すときに、そのクラスローダの loadClass メソッドを使用して指定したパッケージにアクセスする 通常はアクセスできないパッケージ内のクラスに、コードからアクセスできるようになる。このため、悪意のあるコードが、このようなクラスを利用してシステムのセキュリティを脅かす可能性がある
    defineClassInPackage.
    {package name}    		 クラスローダがセキュリティマネージャの checkPackageDefinition メソッドを呼び出すときに、そのクラスローダの defineClass メソッドを使用して、指定したパッケージ内にクラスを定義する これにより、特定のパッケージ内にクラスを定義するためのアクセス権をコードに与えることになる。このアクセス権が与えられた悪意のあるコードは、java.security や java.lang などの信頼できるパッケージ内に破壊行為を行うクラスを定義する可能性があるため、このアクセス権は危険である
    accessDeclaredMembers 警告: このアクセス権をコードに与えるときは、十分な注意を払う必要がある。このアクセス権により、特定のクラスで宣言されているメンバへのアクセスが可能になる 特定のクラス内の public、デフォルト (パッケージ) アクセス、protected、および private なフィールドやメソッドに関する問い合わせを行うコードアクセス権をコードに与えることになる。このアクセス権が与えられたコードは、private および protected なフィールド名とメソッド名にはアクセスできるが、private および protected なフィールドのデータにはアクセスできず、private なメソッドを呼び出すことはできない。しかし、攻撃の狙いをより正確に定めるため、悪意のあるコードがこの情報を利用する可能性がある。また、クラス内の public なメソッドを呼び出したり、public なフィールドにアクセスしたりする可能性がある。コードが、メソッドとフィールドが含まれるクラスやインタフェースにオブジェクトをキャストできないため、通常はコードがこれらのメソッドを呼び出したり、フィールドにアクセスしたりできない場合は危険である
    queuePrintJob 印刷ジョブ要求の発行 機密情報が印刷される可能性があるほか、用紙が浪費される可能性がある

    NIO 関連ターゲット

    Java 2 SDK のリリース 1.4 では、次の 2 つの NIO に関する RuntimePermission ターゲットが追加されました。 
    selectorProvider
charsetProvider
    これらの RuntimePermission は、java.nio.channel.spi.SelectorProvider または java.nio.charset.spi.CharsetProvider をサブクラス化して実装するクラスに付与する必要があります。アクセス権は、抽象基底クラスコンストラクタの呼び出し時にチェックされます。これらのアクセス権は、重要なプロバイダ機構を実装するクラスの信頼性を確証します。

    詳細については、「java.nio.channels.spi.SelectorProvider」 と 「java.nio.channels.spi.CharsetProvider」を参照してください。

    NetPermission

    java.net.NetPermission は、さまざまなネットワークアクセス権を表します。NetPermission には名前は含まれますが、アクションリストは含まれません。したがって、名前付きアクセス権を得るか、アクセス権を得ないかのどちらかになります。

    NetPermission に指定できるターゲット名と、それで与えられるアクセス権により可能になる操作、およびそのアクセス権をコードに与えた場合のリスクを次の表に示します。

    java.net.NetPermission
    のターゲット名    		 可能になる操作 このアクセス権を与えた場合のリスク
    setDefaultAuthenticator プロキシまたは HTTP サーバが証明書を要求したときに使用する、認証情報の取得方法を設定する これにより、ユーザからの入力を取得のときに、ユーザの認証情報入力を監視し、それを盗むオーセンティケータが悪意のあるコードにより設定される可能性がある
    requestPasswordAuthentication システムに登録されたオーセンティケータにパスワードを要求 悪意のあるコードにより、このパスワードが盗まれる可能性がある
    specifyStreamHandler URL の作成時にストリームハンドラを指定 悪質なコードが、それが実際にアクセスする場所から実効バイトを取得するストリームハンドラを指定して、通常はアクセスすることのないリソース (file:/foo/fum/ のように) を使って URL を作成する可能性がある。このようにしてシステムを騙して、あるクラスの出所を偽り、そのクラスの ProtectionDomain/CodeSource を作成させてしまう可能性がある

    SocketPermission

    java.net.SocketPermission は、ソケットを利用したネットワークアクセスを表します。SocketPermission は、ホストの指定と、そのホストへの接続方法を指定したアクションの集合から成ります。ホストは、次のように指定します。

    host = (hostname | IPaddress)[:portrange]
portrange = portnumber | -portnumber | portnumber-[portnumber]

    ホストは、DNS 名、数値による IP アドレス、localhost (ローカルマシンの場合) のどれかで表されます。DNS 名によるホスト指定には、ワイルドカード「*」を 1 回使用できます。これを使う場合は、「*.sun.com」のように一番左の位置に使います。

    ポートまたはポート範囲は省略可能です。ポートを「N-」(N はポート番号) という形で指定した場合は、ポート番号 N とそれより上のすべてのポート番号を表します。また、「-N」という形で指定した場合は、ポート番号 N とそれより下のすべてのポート番号を表します。

    ホストへの接続方法としては、次のどれかを指定できます。

    accept
connect
listen
resolve

    listen アクションは、localhost とともに使用した場合だけ意味を持ちます。resolve (ホストおよび IP ネームサービスの参照を解決) アクションは、それ以外のアクションのどれかを指定すると、自動的に指定したことになります。

    SocketPermissions の作成およびその意味の例として、ポリシーファイルに以下のエントリがある場合を考えてみましょう。

    grant signedBy "mrm" {
permission java.net.SocketPermission "puffin.eng.sun.com:7777", "connect, accept";
};

    このエントリにより、次のアクセス権オブジェクトが生成され、「mrm」により署名されたコードに許可が与えられます。

    p1 = new SocketPermission("puffin.eng.sun.com:7777", "connect,accept");

    p1 は、puffin.eng.sun.com 上のポート 7777 へ接続するアクセス権、および接続を受け付けるアクセス権を表します。

    同様に、ポリシーに次のエントリがあるとします。

    grant signedBy "paul" {
permission java.net.SocketPermission "localhost:1024-", "accept, connect, listen";
};

    このエントリにより、次のアクセス権オブジェクトが生成され、「paul」により署名されたコードに許可が与えられます。

    p2 = new SocketPermission("localhost:1024-", "accept,connect,listen");

    p2 は、ローカルホストの 1024 から 65535 までの任意のポートへの接続の受け付け、そのポートへの接続、およびそのポートでの待機を許可するアクセス権を表します。

    注: リモートホストへの接続要求を受け付けるためのアクセス権やリモートホストへ接続するためのアクセス権をコードに与えると、悪意のあるコードが、そのようなアクセス権がなければそのデータにアクセスできないホスト間で、機密データをより簡単に転送および共有できるようになるため危険です。

    SQLPermission

    アプレット内で実行中のコードが setLogWriter メソッドの 1 つを呼び出す場合に、SecurityManager がチェックするアクセス権。これらのメソッドには、次のリスト内のメソッドが含まれます。

    SQLPermission オブジェクトが存在しない場合、このメソッドは実行時例外として java.lang.SecurityException をスローします。

    SQLPermission オブジェクトには名前 (ターゲット名とも呼ばれる) は含まれますが、アクションリストは含まれません。したがって、名前付きアクセス権が存在するか、存在しないかのどちらかになります。ターゲット名には、アクセス権 (下記を参照) の名前を指定します。命名規約は、階層的なプロパティ命名規約に従います。また、ターゲット名のあとにアスタリスクを指定し (「.」のあとに指定するか、単独で指定)、ワイルドカードによる照合を行うこともできます。次に例を示します。たとえば、「loadLibrary.*」や「*」は有効ですが、「*loadLibrary」や「a*b」は無効です。

    SQLPermission に指定できるターゲット名を次の表に示します。現時点で指定可能な名前は setLog だけです。表には、与えられるアクセス権により可能になる操作、およびそのアクセス権をコードに与えた場合のリスクが示されます。

    アクセス権ターゲット名 可能になる操作 このアクセス権を与えた場合のリスク
    setLog ロギングストリームの設定 このアクセス権を与えるのは危険である。ログの内容には、ユーザ名とパスワード、SQL 文、および SQL データが含まれる

    アプレットを実行するユーザは、許可するアクセス権を決定し、Policy Tool を実行して、ポリシーファイルに SQLPermission を作成します。プログラマは、コンストラクタを直接使用するのではなく、ツールを使って SQLPermission のインスタンスを作成します。

    PropertyPermission

    java.util.PropertyPermission は、プロパティアクセス権を表します。

    名前には、プロパティの名前 (「java.home」や「os.name」など) を指定します。命名規約は、階層的なプロパティ命名規約に従います。また、ターゲット名のあとにアスタリスクを指定し (「.」のあとに指定するか、単独で指定)、ワイルドカードによる照合を行うこともできます。たとえば、「java.*」や「*」は有効ですが、「*java」や「a*b」は無効です。

    許可するアクションは、コンマで区切られた 0 個以上のキーワードのリストを内容とする文字列としてコンストラクタに引き渡されます。有効なキーワードは、「read」および「write」です。それぞれの意味は、次のように定義されます。

    read 読み取り権。System.getProperty を呼び出せるようになる
    write 書き込み権。System.setProperty を呼び出せるようになる

    アクション文字列は、処理される前に小文字に変換されます。

    特定のシステムプロパティへのアクセス権をコードに与えるときは注意してください。たとえば、システムプロパティ java.home へのアクセス権を与えると、悪意のあるコードにより、システム環境に関する機密情報 (実行環境のディレクトリ位置) が盗まれる可能性があります。また、システムプロパティ user.name および user.home へのアクセス権を与えると、悪意のあるコードにより、ユーザ環境に関する重要な情報 (ユーザのアカウント名とホームディレクトリ) が盗まれる可能性があります。

    LoggingPermission

    SecurityManager は、SecurityManager を使用して実行されているコードが、Logger.setLevel などのロギング制御メソッドを呼び出すと、java.util.logging.LoggingPermission オブジェクトをチェックします。

    現在のところ、ロギング構成の制御権限を付与する制御機能は、LoggingPermission による「制御」だけです。たとえば、ハンドラの追加や削除、フィルタの追加や削除、またはロギングレベルの変更によってロギングを制御できるようになります。

    通常、LoggingPermission オブジェクトを直接作成するのではなく、セキュリティポリシーファイルの読み取りに基づいてセキュリティポリシーコードによって作成されます。

    SSLPermission

    javax.net.ssl.SSLPermission クラスは、さまざまなネットワークアクセス権を表します。SSLPermission には名前 (ターゲット名とも呼ばれる) は含まれますが、アクションリストは含まれません。したがって、名前付きアクセス権を指定するか、指定しないかのどちらかになります。

    ターゲット名には、ネットワークアクセス権 (下記を参照) の名前を指定します。命名規約は、階層的なプロパティ命名規約に従います。また、ターゲット名のあとにアスタリスクを指定し (「.」のあとに指定するか、単独で指定)、ワイルドカードによる照合を行うこともできます。たとえば、「foo.*」や「*」は有効ですが、「*foo」や「a*b」は無効です。

    SSLPermission に指定できるターゲット名と、それで与えられるアクセス権により可能になる操作、およびそのアクセス権をコードに与えることにより生じるリスクを次の表に示します。

    アクセス権ターゲット名 可能になる操作 このアクセス権を与えた場合のリスク
    setHostnameVerifier HttpsURLConnection によって接続されているホストと、サーバ証明書の共通名フィールドの不一致を許可するかどうかを判定できるコールバックを設定する 悪意のあるコードが、HttpsURLConnection 要求によって参照されたホスト名を監視したり、無効な共通名を使用するサーバ証明書を許可したりするベリファイアを設定する可能性がある
    getSSLSessionContext SSLSession の SSLSessionContext を取得 悪意のあるコードが、SSL ピアを使用して確立されたセッションを監視したり、セッションを無効にしてパフォーマンスを低下させたりする可能性がある

    AuthPermission

    javax.security.auth.AuthPermission クラスは、認証アクセス権を表します。AuthPermission には名前 (ターゲット名とも呼ばれる) は含まれますが、アクションリストは含まれません。したがって、名前付きアクセス権を得るか、アクセス権を得ないかのどちらかになります。

    現在のところ、AuthPermission オブジェクトは、Subject、SubjectDomainCombiner、LoginContext、および Configuration オブジェクトへのアクセスの保護に使用されます。

    AuthPermission に指定可能なターゲット名と、それで与えられるアクセス権により可能になる操作、およびそのアクセス権をコードに与えた場合のリスクを次の表に示します。

    アクセス権ターゲット名 可能になる操作 このアクセス権を与えた場合のリスク
    doAs Subject.doAs メソッドの呼び出し これにより、アプリケーションは doAs メソッドに指定された Subject の識別情報でコード (Actions) を呼び出すことができるようになる
    doAsPrivileged Subject.doAsPrivileged メソッドの呼び出し これにより、アプリケーションは doAsPrivileged メソッドに指定された Subject の識別情報でコード (Actions) を呼び出すことができるようになる。また、呼び出し側が AccessControlContext として null を渡すと、呼び出し側を呼び出しスタックから削除し、さらにその後のセキュリティ判断からも削除することができる
    getSubject 与えられた AccessControlContext から Subject を取り出す これにより、アプリケーションは認証された Subject へのアクセスを取得する。アプリケーションは Subject の認証された Principal と public の資格にアクセスできるようになる
    getSubjectFromDomainCombiner 与えられた SubjectDomainCombiner から Subject を取り出す これにより、アプリケーションは SubjectDomainCombiner と関連がある、認証された Subject へのアクセスを取得する。アプリケーションは Subject の認証された Principal と public の資格にアクセスできるようになる
    setReadOnly Subject を読み取り専用に設定 これにより、アプリケーションは主体の Principal、public 資格および private 資格を読み取り専用に設定できるようになる。これをサービス妨害拒否の型として使用することができる
    modifyPrincipals Subject の Principal セットを変更 アクセス制御は Subject に関連する Principal に基づいて決定される。このアクセス権により、アプリケーションは Subject の Principal セットを変更し、その後のセキュリティ判断に影響を与えることができる
    modifyPublicCredentials Subject の public 資格セットを変更 このアクセス権により、アプリケーションは Subject から public 資格を追加または削除することができる。private 資格の適切なセットに依存するコードを装って、その Subject に存在する可能性がある
    modifyPrivateCredentials Subject の private 資格セットを変更 このアクセス権により、アプリケーションは Subject から private 資格を追加または削除することができる。private 資格の適切なセットに依存するコードを装って、その Subject に存在する可能性がある
    refreshCredential Refreshable インタフェースを実装する資格 Object を更新 このアクセス権により、アプリケーションは期限切れになる資格を更新することができる
    destroyCredential Destroyable インタフェースを実装する資格 Object を削除 このアクセス権により、アプリケーションはサービス妨害攻撃として資格を削除することができる
    createLoginContext.{name} LoginContext を指定した「名前」でインスタンス化 セキュリティ上の問題から、管理者はすべての LoginModule に対してアプリケーションが認証されるようにしたくない場合がある。このアクセス権により、アプリケーションは指定した「名前」で構成されるログインモジュールを認証することができる
    getLoginConfiguration システム全体のログイン Configuration を取り出す これにより、システムの全アプリケーションに設定されているログインモジュールをすべてアプリケーションで決定することができる
    getLoginConfiguration システム全体のログイン Configuration を取り出す これにより、システムの全アプリケーションに設定されているログインモジュールをすべてアプリケーションで決定することができる
    setLoginConfiguration システム全体のログイン Configuration を設定 これにより、システムの全アプリケーションのログインモジュールをアプリケーションで設定することができる
    refreshLoginConfiguration システム全体のログイン Configuration を更新 これにより、アプリケーションはログイン Configuration を更新できる

    PrivateCredentialPermission

    javax.security.auth.PrivateCredentialPermission クラスは、特定の被認証者に属する private 資格へのアクセスを保護するために使われます。被認証者は、主体のセットによって表されます。

    このアクセス権のターゲット名には、Credential クラス名と、主体のセットを指定します。このアクセス権のアクションとして有効な値は、「read」だけです。ターゲット名は、次の構文に従っている必要があります。 

    CredentialClass {PrincipalClass "PrincipalName"}*
    たとえば、次のアクセス権は、com.sun.Principal と「duke」という名前を持つ被認証者によって所有された com.sun.PrivateCredential へのアクセスを許可します。

    注: この例と以下のすべての例では、grant 文内に Codebase、SignedBy、または Principal の情報が含まれていませんが、実際のポリシーの設定では、必要に応じてこれらの情報を指定します。 

    grant {
permission javax.security.auth.PrivateCredentialPermission
"com.sun.PrivateCredential com.sun.Principal \"duke\"",
"read";
};
    CredentialClass が「*」になっている場合は、指定した被認証者に属するすべての private 資格へのアクセス権が付与されます。PrincipalName が「*」になっている場合は、指定した主体を含むすべての被認証者によって所有されている対象の資格へのアクセス権が付与されます。実際の PrincipalName は重要ではありません。たとえば、次の構文は、a.b.Principal を含むすべての被認証者によって所有されている a.b.Credential へのアクセス権を付与します。 
    grant {
permission javax.security.auth.PrivateCredentialPermission
"a.b.Credential a.b.Principal "*"",
"read";
};
    PrincipalClass と PrincipalName の両方が 「*」になっている場合は、すべての被認証者によって所有されている指定した資格へのアクセス権が付与されます。また、PrincipalClass/PrincipalName の対は、繰り返し指定できます。 
    grant {
permission javax.security.auth.PrivateCredentialPermission
"a.b.Credential a.b.Principal "duke" c.d.Principal "dukette"",
"read";
};
    上記のコードは、private 資格「a.b.Credential」へのアクセス権を付与します。この資格は、「duke」という名前を持つ「a.b.Principal」と「dukette」という名前を持つ「c.d.Principal」の少なくとも 2 つの主体に関連付けられた被認証者に属します。

    DelegationPermission

    javax.security.auth.kerberos.DelegationPermission クラスは、Kerberos 委譲モデルの使用 (すなわち転送可能チケットとプロキシ化可能チケット) を制限するために使われます。

    このアクセス権のターゲット名には、kerberos サービス主体の対を指定します。最初の主体には、チケット認可チケット (Ticket Granting Ticket、TGT) の使用を委譲される下位のサービス主体を指定します。2 番目のサービス主体には、下位のサービス主体が KerberosPrincipal を起動するために対話するターゲットサービスを指定します。後者のサービス主体は、プロキシ化可能チケットの使用を制限するために指定します。

    たとえば、「host」サービスによる転送可能 TGT の使用を指定するには、次のようにターゲットのアクセス権を指定します。 

    DelegationPermission("\"host/foo.example.com@EXAMPLE.COM\" \"krbtgt/EXAMPLE.COM@EXAMPLE.COM\"");
    「backup」サービスにプロキシ化可能な NFS サービス チケットを付与するには、ターゲットのアクセス権を次のように指定します。 
    DelegationPermission("\"backup/bar.example.com@EXAMPLE.COM\" \"nfs/home.EXAMPLE.COM@EXAMPLE.COM\"");

    ServicePermission

    javax.security.auth.kerberos.ServicePermission クラスは、Kerberos サービスと、それらのサービスにアクセスするために必要な資格を保護するために使われます。サービス主体とサービスにアクセスするために必要な資格は 1 対 1 で対応します。そのため、サービス主体にアクセス権を付与すると、そのサービス主体とのセキュリティコンテキストを確立するために必要な資格に対する暗黙的なアクセス権を付与することになります。これは、資格が、キャッシュ内にある場合にも、KDC との交換によって獲得される場合にも当てはまります。資格は、TGT、あるいは鍵テーブルから取得されるサービスチケットまたは秘密鍵のいずれかになります。

    ServicePermission は、サービス主体名と、資格を使用できるコンテキストを指定するアクションのリストを含んでいます。

    サービス主体名は、サービスを提供する KereberosPrincipal の標準名です。つまり、KerberosPrincipal は、Kerberos サービス主体を表します。この名前では、大文字と小文字が区別されます。

    このアクセス権を付与すると、呼び出し側が、アクションによって指定されたコンテキスト内で、キャッシュされた資格 (チケット認可チケット (TGT)、サービスチケット、秘密鍵) を使用できるようになります。TGT の場合、このアクセス権の付与によってさらに、認証サービス交換によって TGT を取得することも可能になります。

    次の操作を指定できます。

    initiate 呼び出し側が、資格を使用して、サービス主体内でセキュリティコンテキストを開始できる
    accept 呼び出し側が、資格を使用して、特定の主体としてセキュリティコンテキストを受け入れることができる

    たとえば、TGT にアクセスしてセキュリティコンテキストを開始するためのアクセス権を指定するには、次のようにアクセス権を作成します。 
         ServicePermission("krbtgt/EXAMPLE.COM@EXAMPLE.COM", "initiate");
    サービスチケットを取得し、「host」サービスを使用してコンテキストを開始するには、次のようにアクセス権を作成します。 
    ServicePermission("host/foo.example.com@EXAMPLE.COM", "initiate");
    Kerberos 化されたサーバの場合、アクションは「accept」になります。たとえば、kerberos 化された「host」サービス (telnet など) の秘密鍵にアクセスして使用するために必要なアクセス権は、次のように作成します。 
    ServicePermission("host/foo.example.com@EXAMPLE.COM", "accept");

    AudioPermission

    AudioPermission クラスは、オーディオシステムリソースへのアクセス権を表します。AudioPermission にはターゲット名は含まれますが、アクションリストは含まれません。したがって、名前付きアクセス権を得るか、アクセス権を得ないかのどちらかになります。

    ターゲット名には、オーディオのアクセス権 (下記の表を参照) の名前を指定します。名前は、階層的なプロパティ命名規約に従います。また、アスタリスクを使って、すべてのオーディオのアクセス権を表すこともできます。

    AudioPermission に指定できるターゲット名を次の表に示します。表には、ターゲット名ごとに、そのアクセス権により可能になる操作、およびそのアクセス権をコードに与えることにより生じるリスクも示します。

    アクセス権ターゲット名 可能になる操作 このアクセス権を与えた場合のリスク
    play システムのオーディオデバイスを介して実行されるオーディオ再生。これにより、オーディオ再生 (レンダリング) 用のラインとミキサーの取得および操作が可能になる 場合によっては、このアクセス権を使用することにより、他のアプリケーションが影響を受けることがある。これは、あるラインのオーディオが他のオーディオとミックスされてシステムで再生される可能性があるため、また、ミキサーを操作するとそのミキサーを使用するすべてのラインのオーディオが影響を受けるためである
    record システムのオーディオデバイスを介して実行されるオーディオの録音。これにより、オーディオ録音 (取り込み) 用のラインとミキサーの取得および操作が可能になる 場合によっては、このアクセス権を使用することにより、他のアプリケーションが影響を受けることがある。これは、ミキサーを操作するとそのミキサーを使用するすべてのラインのオーディオが影響を受けるためである。このアクセス権を使用すると、アプレットまたはアプリケーションからユーザーの盗聴を行うことが可能になる

    必要とされるメソッドおよびアクセス権

    ここでは、アクセス権が必要なすべてのメソッドを示すとともに、どの SecurityManager メソッドを必要とするか、およびどのアクセス権が SecurityManager メソッドのデフォルト実装によって検査されるかを示します。

    したがって、SecurityManager メソッドのデフォルトの実装により、右側の列で示されているアクセス権が現在有効なポリシーで与えられている場合だけ、左側の列で示したメソッドを呼び出すことができます。次に例を示します。

    メソッド 呼び出される SecurityManager メソッド アクセス権 
    java.awt.Toolkit
getSystemEventQueue();
    		checkAwtEventQueueAccess java.awt.AWTPermission "accessEventQueue";

    この場合、java.awt.Toolkit クラスの getSystemEventQueue メソッドへの呼び出しは、SecurityManager メソッド checkAwtEventQueueAccess への呼び出しになります。このメソッドは、呼び出しスタック上のコードに次のアクセス権が与えられている場合にだけ呼び出せます。

    java.awt.AWTPermission "accessEventQueue";

    次のような形式の場合、

    メソッド 呼び出される SecurityManager メソッド アクセス権 
    some.package.class
public static void someMethod(String foo);
    		checkXXX SomePermission "{foo}";

    アクセス権名中の文字列 {foo} は foo の実行時の値で置き換えられるという意味です。

    次の例を見てください。

    メソッド 呼び出される SecurityManager メソッド アクセス権 
    java.io.FileInputStream
FileInputStream(String name)
    		checkRead(String) java.io.FilePermission "{name}", "read";

    FileInputStream メソッド (この場合はコンストラクタ) を、次のように引数 name に /test/MyTestFile を指定して呼び出したとします。

    FileInputStream("/test/MyTestFile");

    この呼び出しは、現在のポリシーで次のアクセス権が設定され、/test/MyTestFile ファイルへの読み取りアクセスが許可されていないと行えません。

    java.io.FilePermission "/test/MyTestFile", "read";

    より正確には、アクセス権は、このように明示的に設定されているか、次のように、別のアクセス権により暗黙に設定されている必要があります。

    java.io.FilePermission "/test/*", "read";

    この例では、/test ディレクトリに含まれる任意のファイルへの読み取りアクセスが許可されています。

    中括弧で囲まれた項目が、特定のメソッド引数と同一ではなく、関係のある値を表す場合もあります。次に例を示します。

    メソッド 呼び出される SecurityManager メソッド アクセス権 
    java.net.DatagramSocket
public synchronized void
receive(DatagramPacket p);
    		 checkAccept({host}, {port}) java.net.SocketPermission "{host}:{port}", "accept";

    ここでは、適切なホストおよびポートの値が receive メソッドにより計算されて、checkAccept に渡されます。

    ほとんどの場合、呼び出される SecurityManager のメソッドが一覧表示されます。メソッドは、複数ある同名のメソッドのどれかであり、引数の型も一覧表示されます。たとえば、checkRead(String) および checkRead(FileDescriptor) などがあります。引数が関係するその他の場合にも、引数は一覧表示されます。

    以下の表は、パッケージ名の順に並べられています。つまり、最初に java.awt パッケージクラス内のメソッド、次に java.io パッケージクラス内のメソッド、という順番です。

    必要とされるメソッドおよびアクセス権
    メソッド 呼び出される SecurityManager メソッド アクセス権 
    java.awt.Graphics2d
public abstract void
setComposite(Composite comp)
    		 checkPermission java.awt.AWTPermission "readDisplayPixels"。この Graphics2D コンテキストが画面上の Component に描画中であり、かつ Composite が AlphaComposite クラスのインスタンスではなく、カスタムオブジェクトの場合。注: setComposite メソッドは、実際には abstract メソッドであるため、セキュリティチェックを呼び出すことはできない。こうした条件下では、メソッドの実装ごとに java.lang.SecurityManager checkPermission メソッドを java.awt.AWTPermission("readDisplayPixels") アクセス権で呼び出す必要がある 
    java.awt.Robot
public Robot()
public Robot(GraphicsDevice screen)
    		 checkPermission java.awt.AWTPermission "createRobot" 
    java.awt.Toolkit
public void addAWTEventListener(
AWTEventListener listener,
long eventMask)
public void removeAWTEventListener(
AWTEventListener listener)
    		 checkPermission java.awt.AWTPermission "listenToAllAWTEvents" 
    java.awt.Toolkit
public abstract PrintJob getPrintJob(
Frame frame, String jobtitle,
Properties props)
    		 checkPrintJobAccess

    java.lang.RuntimePermission "queuePrintJob"

    注: getPrintJob メソッドは実際には abstract メソッドなので、セキュリティチェックを起動することはできない。getPrintJob メソッドの実際の各実装部分では、java.lang.SecurityManager の checkPrintJobAccess メソッドを呼び出すべき。このメソッドは、アクセス権 java.lang.RuntimePermission "queuePrintJob" が現在許可されている場合だけ呼び出すことができる

    		 
    java.awt.Toolkit
public abstract Clipboard
getSystemClipboard()
    		 checkSystemClipboardAccess

    java.awt.AWTPermission "accessClipboard"

    注: getSystemClipboard メソッドは実際には abstract メソッドなので、セキュリティチェックを起動することはできない。getSystemClipboard メソッドの実際の各実装部分では、java.lang.SecurityManager checkSystemClipboardAccess メソッドを呼び出すべき。このメソッドは、アクセス権 java.awt.AWTPermission "accessClipboard" が現在許可されている場合だけ呼び出すことができる

    		 
    java.awt.Toolkit
public final EventQueue
getSystemEventQueue()
    		 checkAwtEventQueueAccess java.awt.AWTPermission "accessEventQueue" 
    java.awt.Window
Window()
    		 checkTopLevelWindow java.awt.AWTPermission "showWindowWithoutWarningBanner" が設定されていると、ウィンドウが表示されるときに、そのウィンドウがアプレットによって作成されていることを警告するバナーは表示されない。設定されていない場合は、バナーが表示される 
    java.beans.Beans
public static void setDesignTime(
boolean isDesignTime)
public static void setGuiAvailable(
boolean isGuiAvailable)

java.beans.Introspector
public static synchronized void
setBeanInfoSearchPath(String path[])

java.beans.PropertyEditorManager
public static void registerEditor(
Class targetType,
Class editorClass)
public static synchronized void
setEditorSearchPath(String path[])
    		 checkPropertiesAccess java.util.PropertyPermission "*", "read,write" 
    java.io.File
public boolean delete()
public void deleteOnExit()
    		 checkDelete(String) java.io.FilePermission "{name}", "delete" 
    java.io.FileInputStream
FileInputStream(FileDescriptor fdObj)
    		 checkRead(FileDescriptor) java.lang.RuntimePermission "readFileDescriptor" 
    java.io.FileInputStream
FileInputStream(String name)
FileInputStream(File file)

java.io.File
public boolean exists()
public boolean canRead()
public boolean isFile()
public boolean isDirectory()
public boolean isHidden()
public long lastModified()
public long length()
public String[] list()
public String[] list(
FilenameFilter filter)
public File[] listFiles()
public File[] listFiles(
FilenameFilter filter)
public File[] listFiles(
FileFilter filter)
      
java.io.RandomAccessFile
RandomAccessFile(String name, String mode)
RandomAccessFile(File file, String mode)
(where mode is "r" in both of these)
    		 checkRead(String) java.io.FilePermission "{name}", "read" 
    java.io.FileOutputStream
FileOutputStream(FileDescriptor fdObj)
    		 checkWrite(FileDescriptor) java.lang.RuntimePermission "writeFileDescriptor" 
    java.io.FileOutputStream
FileOutputStream(File file)
FileOutputStream(String name)
FileOutputStream(String name,
boolean append)

java.io.File
public boolean canWrite()
public boolean createNewFile()
public static File createTempFile(
String prefix, String suffix)
public static File createTempFile(
String prefix,  String suffix,
File directory)
public boolean mkdir()
public boolean mkdirs()
public boolean renameTo(File dest)
public boolean setLastModified(long time)
public boolean setReadOnly()
    		 checkWrite(String) java.io.FilePermission "{name}", "write" 
    java.io.ObjectInputStream
protected final boolean
enableResolveObject(boolean enable);

java.io.ObjectOutputStream
protected final boolean
enableReplaceObject(boolean enable)
    		 checkPermission java.io.SerializablePermission "enableSubstitution" 
    java.io.ObjectInputStream
protected ObjectInputStream()

java.io.ObjectOutputStream
protected ObjectOutputStream()
    		 checkPermission java.io.SerializablePermission "enableSubclassImplementation" 
    java.io.RandomAccessFile
RandomAccessFile(String name, String mode)
(where mode is "rw")
    		 checkRead(String) and checkWrite(String) java.io.FilePermission "{name}", "read,write" 
    java.lang.Class
public static Class forName(
String name, boolean initialize,
ClassLoader loader)
    		 checkPermission loader が null で、呼び出し側のクラスローダは null でない場合、java.lang.RuntimePermission("getClassLoader") になる 
    java.lang.Class
public Class[] getClasses()
    		 このクラスおよびその各スーパークラスで、checkMemberAccess(this, Member.DECLARED) が呼び出される。また、このクラスがパッケージ内にある場合は、checkPackageAccess({pkgName}) が呼び出される このクラスのクラスローダが呼び出し側のクラスローダと同一である場合は、デフォルトの checkMemberAccess はいかなるアクセス権も必要としない。同一でない場合は、java.lang.RuntimePermission "accessDeclaredMembers" が必要。このクラスがパッケージ内にある場合、java.lang.RuntimePermission "accessClassInPackage.{pkgName}" も必要 
    java.lang.Class
public ClassLoader getClassLoader()
    		 checkPermission 呼び出し側のクラスローダが null の場合、あるいは呼び出し側のクラスローダが、クラスローダが要求されているクラスのクラスローダと同じかその上位クラスの場合は、アクセス権は必要ない。それ以外の場合は、
    java.lang.RuntimePermission "getClassLoader" が
    必要    		 
    java.lang.Class
public Class[] getDeclaredClasses()
public Field[] getDeclaredFields()
public Method[] getDeclaredMethods()
public Constructor[]
getDeclaredConstructors()
public Field getDeclaredField(
String name)
public Method getDeclaredMethod(...)
public Constructor
getDeclaredConstructor(...)
    		 checkMemberAccess(this, Member.DECLARED)、およびこのクラスがパッケージ内にある場合は checkPackageAccess({pkgName}) このクラスのクラスローダが呼び出し側のクラスローダと同一である場合は、デフォルトの checkMemberAccess はいかなるアクセス権も必要としない。同一でない場合は、java.lang.RuntimePermission "accessDeclaredMembers" が必要。このクラスがパッケージ内にある場合、java.lang.RuntimePermission "accessClassInPackage.{pkgName}" も必要 
    java.lang.Class
public Field[] getFields()
public Method[] getMethods()
public Constructor[] getConstructors()
public Field getField(String name)
public Method getMethod(...)
public Constructor getConstructor(...)
    		 checkMemberAccess(this, Member.PUBLIC)、およびこのクラスがパッケージ内にある場合は checkPackageAccess({pkgName}) アクセスタイプが Member.PUBLIC の場合、デフォルトの checkMemberAccess はどのようなアクセス権も必要としない。このクラスがパッケージ内にある場合、java.lang.RuntimePermission "accessClassInPackage.{pkgName}" が必要 
    java.lang.Class
public ProtectionDomain
getProtectionDomain()
    		 checkPermission java.lang.RuntimePermission "getProtectionDomain" 
    java.lang.ClassLoader
ClassLoader()
ClassLoader(ClassLoader parent)
    		 checkCreateClassLoader java.lang.RuntimePermission "createClassLoader" 
    java.lang.ClassLoader
public static ClassLoader
getSystemClassLoader()
public ClassLoader getParent()
    		 checkPermission 呼び出し側のクラスローダが null の場合、あるいは呼び出し側のクラスローダが、クラスローダが要求されているクラスのクラスローダと同じかその上位クラスの場合は、アクセス権は必要ない。それ以外の場合は、
    java.lang.RuntimePermission "getClassLoader" が
    必要    		 
    java.lang.Runtime
public Process exec(String command)
public Process exec(String command,
String envp[])
public Process exec(String cmdarray[])
public Process exec(String cmdarray[],
String envp[])
    		 checkExec java.io.FilePermission "{command}", "execute" 
    java.lang.Runtime
public void exit(int status)
public static void
runFinalizersOnExit(boolean value)
java.lang.System
public static void exit(int status)
public static void
runFinalizersOnExit(boolean value)
    		 checkExit(status)。このとき、runFinalizersOnExit に対して status は 0 java.lang.RuntimePermission "exitVM" 
    java.lang.Runtime
public void addShutdownHook(Thread hook)
public boolean removeShutdownHook(Thread hook)
    		 checkPermission java.lang.RuntimePermission "shutdownHooks" 
    java.lang.Runtime
public void load(String lib)
public void loadLibrary(String lib)
java.lang.System
public static void load(String filename)
public static void loadLibrary(
String libname)
    		 checkLink({libName}) ただし、{libName} は lib、filename または libname 引数 java.lang.RuntimePermission "loadLibrary.{libName}" 
    java.lang.SecurityManager メソッド
    		 checkPermission 次の表を参照 
    java.lang.System
public static Properties
getProperties()
public static void
setProperties(Properties props)
    		 checkPropertiesAccess java.util.PropertyPermission "*", "read,write" 
    java.lang.System
public static String
getProperty(String key)
public static String
getProperty(String key, String def)
    		 checkPropertyAccess java.util.PropertyPermission "{key}", "read" 
    java.lang.System
public static void setIn(InputStream in)
public static void setOut(PrintStream out)
public static void setErr(PrintStream err)
    		 checkPermission java.lang.RuntimePermission "setIO" 
    java.lang.System
public static String
setProperty(String key, String value)
    		 checkPermission java.util.PropertyPermission "{key}", "write" 
    java.lang.System
public static synchronized void
setSecurityManager(SecurityManager s)
    		 checkPermission java.lang.RuntimePermission "setSecurityManager" 
    java.lang.Thread
public ClassLoader getContextClassLoader()
    		 checkPermission 呼び出し側のクラスローダが null の場合、あるいは呼び出し側のクラスローダが、コンテキストクラスローダが要求されているスレッドのコンテキストクラスローダと同じかその上位クラスの場合は、アクセス権は必要ない。それ以外の場合は、
    java.lang.RuntimePermission "getClassLoader" が
    必要    		 
    java.lang.Thread
public void setContextClassLoader
(ClassLoader cl)
    		 checkPermission java.lang.RuntimePermission "setContextClassLoader" 
    java.lang.Thread
public final void checkAccess()
public void interrupt()
public final void suspend()
public final void resume()
public final void setPriority
(int newPriority)
public final void setName(String name)
public final void setDaemon(boolean on)
    		 checkAccess(this) java.lang.RuntimePermission "modifyThread" 
    java.lang.Thread
public static int
enumerate(Thread tarray[])
    		 checkAccess({threadGroup}) java.lang.RuntimePermission "modifyThreadGroup" 
    java.lang.Thread
public final void stop()
    		 checkAccess(this)。現在のスレッドが自分以外のスレッドを停止させようとしている場合は、checkPermission も呼び出される java.lang.RuntimePermission "modifyThread".
    現在のスレッドが自分以外のスレッドを停止させようとしている場合、java.lang.RuntimePermission "stopThread" も必要    		 
    java.lang.Thread
public final synchronized void
stop(Throwable obj)
    		 checkAccess(this)。現在のスレッドが自分以外のスレッドを停止させようとしている場合、または obj が ThreadDeath のインスタンスでない場合は、checkPermission も呼び出される java.lang.RuntimePermission "modifyThread".
    現在のスレッドが自分以外のスレッドを停止させようとしている場合、または obj が ThreadDeath のインスタンスではない場合は、java.lang.RuntimePermission "stopThread" も必要    		 
    java.lang.Thread
Thread()
Thread(Runnable target)
Thread(String name)
Thread(Runnable target, String name)

java.lang.ThreadGroup
ThreadGroup(String name)
ThreadGroup(ThreadGroup parent,
String name)
    		 checkAccess({parentThreadGroup}) java.lang.RuntimePermission "modifyThreadGroup" 
    java.lang.Thread
Thread(ThreadGroup group, ...)

java.lang.ThreadGroup
public final void checkAccess()
public int enumerate(Thread list[])
public int enumerate(Thread list[],
boolean recurse)
public int enumerate(ThreadGroup list[])
public int enumerate(ThreadGroup list[],
boolean recurse)
public final ThreadGroup getParent()
public final void
setDaemon(boolean daemon)
public final void setMaxPriority(int pri)
public final void suspend()
public final void resume()
public final void destroy()
    		 ThreadGroup メソッドの場合は checkAccess(this)、Thread メソッドの場合は checkAccess(group) java.lang.RuntimePermission "modifyThreadGroup" 
    java.lang.ThreadGroup
public final void interrupt()
    		 checkAccess(this) java.lang.RuntimePermission "modifyThreadGroup" が必要。
    また、スレッドグループとそのすべてのサブグループのスレッドごとに java.lang.Thread interrupt() メソッドが呼び出されるため、java.lang.RuntimePermission "modifyThread" も必要。Thread interrupt() メソッドを参照    		 
    java.lang.ThreadGroup
public final void stop()
    		 checkAccess(this) java.lang.RuntimePermission "modifyThreadGroup" が必要。
    また、java.lang.Thread の stop() メソッドは、そのスレッドグループおよびすべてのサブグループでスレットごとに呼び出されるので、java.lang.RuntimePermission "modifyThread" および場合によっては java.lang.RuntimePermission "stopThread" が必要。Thread の stop() メソッドを参照    		 
    java.lang.reflect.AccessibleObject
public static void setAccessible(...)
public void setAccessible(...)
    		 checkPermission java.lang.reflect.ReflectPermission "suppressAccessChecks" 
    java.net.Authenticator
public static PasswordAuthentication
requestPasswordAuthentication(
InetAddress addr,
int port,
String protocol,
String prompt,
String scheme)
    		 checkPermission java.net.NetPermission "requestPasswordAuthentication" 
    java.net.Authenticator
public static void
setDefault(Authenticator a)
    		 checkPermission java.net.NetPermission "setDefaultAuthenticator" 
    java.net.MulticastSocket
public void
joinGroup(InetAddress mcastaddr)
public void
leaveGroup(InetAddress mcastaddr)
    		 checkMulticast(InetAddress) java.net.SocketPermission( mcastaddr.getHostAddress(), "accept,connect") 
    java.net.DatagramSocket
public void send(DatagramPacket p)
    		 checkMulticast(p.getAddress()) または checkConnect(
    p.getAddress().getHostAddress(), p.getPort())    		 if (p.getAddress().isMulticastAddress()) {
    java.net.SocketPermission(
    (p.getAddress()).getHostAddress(), "accept,connect")
    }
    else {
    port = p.getPort();
    host = p.getAddress().getHostAddress();
    if (port == -1) java.net.SocketPermission "{host}","resolve";
    else java.net.SocketPermission "{host}:{port}","connect"
    }    		 
    java.net.MulticastSocket
public synchronized void
send(DatagramPacket p, byte ttl)
    		 checkMulticast(p.getAddress(), ttl) or checkConnect(
    p.getAddress().getHostAddress(), p.getPort())    		 if (p.getAddress().isMulticastAddress()) {
    java.net.SocketPermission(
    (p.getAddress()).getHostAddress(), "accept,connect")
    }
    else {
    port = p.getPort();
    host = p.getAddress().getHostAddress();
    if (port == -1) java.net.SocketPermission "{host}","resolve";
    else java.net.SocketPermission "{host}:{port}","connect"
    }    		 
    java.net.InetAddress
public String getHostName()
public static InetAddress[]
getAllByName(String host)
public static InetAddress getLocalHost()

java.net.DatagramSocket
public InetAddress getLocalAddress()
    		 checkConnect({host}, -1) java.net.SocketPermission "{host}", "resolve" 
    java.net.ServerSocket
ServerSocket(...)

java.net.DatagramSocket
DatagramSocket(...)

java.net.MulticastSocket
MulticastSocket(...)
    		 checkListen({port}) if (port == 0) java.net.SocketPermission "localhost:1024-","listen";
    else java.net.SocketPermission "localhost:{port}","listen"    		 
    java.net.ServerSocket
public Socket accept()
protected final void implAccept(Socket s)
    		 checkAccept({host}, {port}) java.net.SocketPermission "{host}:{port}", "accept" 
    java.net.ServerSocket
public static synchronized void
setSocketFactory(...)

java.net.Socket
public static synchronized void
setSocketImplFactory(...)

java.net.URL
public static synchronized void
setURLStreamHandlerFactory(...)

java.net.URLConnection
public static synchronized void
setContentHandlerFactory(...)
public static void
setFileNameMap(FileNameMap map)

java.net.HttpURLConnection
public static void
setFollowRedirects(boolean set)

java.rmi.activation.ActivationGroup
public static synchronized
	ActivationGroup createGroup(...)
public static synchronized void
setSystem(ActivationSystem system)

java.rmi.server.RMISocketFactory
public synchronized static void
setSocketFactory(...)
    		 checkSetFactory java.lang.RuntimePermission "setFactory" 
    java.net.Socket
Socket(...)
    		 checkConnect({host}, {port}) java.net.SocketPermission "{host}:{port}", "connect" 
    java.net.DatagramSocket
public synchronized void
receive(DatagramPacket p)
    		 checkAccept({host}, {port}) java.net.SocketPermission "{host}:{port}", "accept" 
    java.net.URL
URL(...)
    		 checkPermission java.net.NetPermission "specifyStreamHandler" 
    java.net.URLClassLoader
URLClassLoader(...)
    		 checkCreateClassLoader java.lang.RuntimePermission "createClassLoader" 
    java.security.AccessControlContext
public AccessControlContext(AccessControlContext acc,
				DomainCombiner combiner)
public DomainCombiner getDomainCombiner()
    		 checkPermission java.security.SecurityPermission "createAccessControlContext" 
    java.security.Identity
public void addCertificate(...)
    		 checkSecurityAccess(
    "addIdentityCertificate")    		 java.security.SecurityPermission "addIdentityCertificate" 
    java.security.Identity
public void removeCertificate(...)
    		 checkSecurityAccess(
    "removeIdentityCertificate")    		 java.security.SecurityPermission "removeIdentityCertificate" 
    java.security.Identity
public void setInfo(String info)
    		 checkSecurityAccess(
    "setIdentityInfo")    		 java.security.SecurityPermission "setIdentityInfo" 
    java.security.Identity
public void setPublicKey(PublicKey key)
    		 checkSecurityAccess(
    "setIdentityPublicKey")    		 java.security.SecurityPermission "setIdentityPublicKey" 
    java.security.Identity
public String toString(...)
    		 checkSecurityAccess(
    "printIdentity")    		 java.security.SecurityPermission "printIdentity" 
    java.security.IdentityScope
protected static void setSystemScope()
    		 checkSecurityAccess(
    "setSystemScope")    		 java.security.SecurityPermission "setSystemScope" 
    java.security.Permission
public void checkGuard(Object object)
    		checkPermission(this) このアクセス権オブジェクトが検査されたアクセス権 
    java.security.Policy
public static Policy getPolicy()
    		 checkPermission java.security.SecurityPermission "getPolicy" 
    java.security.Policy
public static void
setPolicy(Policy policy);
    		 checkPermission java.security.SecurityPermission "setPolicy" 
    java.security.Provider
public synchronized void clear()
    		 checkSecurityAccess(
    "clearProviderProperties."+{name})    		 java.security.SecurityPermission "clearProviderProperties.{name}"; name には、プロバイダ名を指定する 
    java.security.Provider
public synchronized Object
put(Object key, Object value)
    		 checkSecurityAccess(
    "putProviderProperty."+{name})    		 java.security.SecurityPermission "putProviderProperty.{name}"; name には、プロバイダ名を指定する 
    java.security.Provider
public synchronized Object
remove(Object key)
    		 checkSecurityAccess(
    "removeProviderProperty."+{name})    		 java.security.SecurityPermission "removeProviderProperty.{name}"; name には、プロバイダ名を指定する 
    java.security.SecureClassLoader
SecureClassLoader(...)
    		 checkCreateClassLoader java.lang.RuntimePermission "createClassLoader" 
    java.security.Security
public static void getProperty(String key)
    		 checkPermission java.security.SecurityPermission "getProperty.{key}" 
    java.security.Security
public static int
addProvider(Provider provider)
public static int
insertProviderAt(Provider provider,
int position);
    		 checkSecurityAccess(
    "insertProvider."+provider.getName())    		 java.security.SecurityPermission "insertProvider.{name}" 
    java.security.Security
public static void
removeProvider(String name)
    		 checkSecurityAccess(
    "removeProvider."+name)    		 java.security.SecurityPermission "removeProvider.{name}" 
    java.security.Security
public static void
setProperty(String key, String datum)
    		 checkSecurityAccess(
    "setProperty."+key)    		 java.security.SecurityPermission "setProperty.{key}" 
    java.security.Signer
public PrivateKey getPrivateKey()
    		 checkSecurityAccess(
    "getSignerPrivateKey")    		 java.security.SecurityPermission "getSignerPrivateKey" 
    java.security.Signer
public final void
setKeyPair(KeyPair pair)
    		checkSecurityAccess(
    "setSignerKeypair")    		 java.security.SecurityPermission "setSignerKeypair" 
    java.sql.DriverManager
public static synchronized void
setLogWriter(PrintWriter out)
    		checkPermission java.sql.SQLPermission "setLog" 
    java.sql.DriverManager
public static synchronized void
setLogStream(PrintWriter out)
    		checkPermission java.sql.SQLPermission "setLog" 
    java.util.Locale
public static synchronized void
setDefault(Locale newLocale)
    		 checkPermission java.util.PropertyPermission "user.language","write" 
    java.util.zip.ZipFile
ZipFile(String name)
    		 checkRead java.io.FilePermission "{name}","read" 
    javax.security.auth.Subject
public static Subject getSubject(final AccessControlContext acc)
    		 checkPermission javax.security.auth.AuthPermission "getSubject" 
    javax.security.auth.Subject
public void setReadOnly()
    		 checkPermission javax.security.auth.AuthPermission "setReadOnly" 
    javax.security.auth.Subject
public static Object doAs(final Subject subject,
				final PrivilegedAction action)
    		 checkPermission javax.security.auth.AuthPermission "doAs" 
    javax.security.auth.Subject
public static Object doAs(final Subject subject,
				final PrivilegedExceptionAction action)
	throws java.security.PrivilegedActionException
    		 checkPermission javax.security.auth.AuthPermission "doAs" 
    javax.security.auth.Subject
public static Object doAsPrivileged(final Subject subject,
				final PrivilegedAction action,
				final AccessControlContext acc)
    		 checkPermission javax.security.auth.AuthPermission "doAsPrivileged" 
    javax.security.auth.Subject
public static Object doAsPrivileged(final Subject subject,
				final PrivilegedExceptionAction action,
				final AccessControlContext acc)
	throws java.security.PrivilegedActionException
    		 checkPermission javax.security.auth.AuthPermission "doAsPrivileged" 
    javax.security.auth.SubjectDomainCombiner
public Subject getSubject()
    		 checkPermission javax.security.auth.AuthPermission "getSubjectFromDomainCombiner" 
    javax.security.auth.SubjectDomainCombiner
public Subject getSubject()
    		 checkPermission javax.security.auth.AuthPermission "getSubjectFromDomainCombiner" 
    javax.security.auth.login.LoginContext
public LoginContext(String name)
	throws LoginException
    		 checkPermission javax.security.auth.AuthPermission "createLoginContext.{name}" 
    javax.security.auth.login.LoginContext
public LoginContext(String name,
			Subject subject)
	 throws LoginException
    		 checkPermission javax.security.auth.AuthPermission "createLoginContext.{name}" 
    javax.security.auth.login.LoginContext
public LoginContext(String name,
			CallbackHandler callbackHandler)
	 throws LoginException
    		 checkPermission javax.security.auth.AuthPermission "createLoginContext.{name}" 
    javax.security.auth.login.LoginContext
public LoginContext(String name,
			Subject subject,
			CallbackHandler callbackHandler)
	 throws LoginException
    		 checkPermission javax.security.auth.AuthPermission "createLoginContext.{name}" 
    javax.security.auth.login.Configuration
public static Configuration getConfiguration()
    		 checkPermission javax.security.auth.AuthPermission "getLoginConfiguration" 
    javax.security.auth.login.Configuration
public static void setConfiguration(Configuration configuration)
    		 checkPermission javax.security.auth.AuthPermission "setLoginConfiguration" 
    javax.security.auth.login.Configuration
public static void refresh()
    		 checkPermission javax.security.auth.AuthPermission "refreshLoginConfiguration"


    java.lang.SecurityManager のメソッドとその呼び出しに必要なアクセス権

    次の表では、java.lang.SecurityManager メソッドのデフォルトの実装によって検査されるアクセス権を示します。

    指定された各 check メソッドは SecurityManager checkPermission メソッドを指定されたアクセス権で呼び出します (コンテキスト引数をとる checkConnect および checkRead メソッドを除く)。これらのメソッドは、AccessControlContext コンテキストを想定し、コンテキストの checkPermission メソッドを指定されたアクセス権で呼び出します。

    メソッド アクセス権
    public void checkAccept(String host, int port); java.net.SocketPermission "{host}:{port}", "accept";
    public void checkAccess(Thread g); java.lang.RuntimePermission "modifyThread");
    public void checkAccess(ThreadGroup g); java.lang.RuntimePermission "modifyThreadGroup");
    public void checkAwtEventQueueAccess(); java.awt.AWTPermission "accessEventQueue";
    public void checkConnect(String host, int port); if (port == -1) java.net.SocketPermission "{host}","resolve";
    else java.net.SocketPermission "{host}:{port}","connect";
    public void checkConnect(String host, int port, Object context); if (port == -1) java.net.SocketPermission "{host}","resolve";
    else java.net.SocketPermission "{host}:{port}","connect";
    public void checkCreateClassLoader(); java.lang.RuntimePermission "createClassLoader";
    public void checkDelete(String file); java.io.FilePermission "{file}", "delete";
    public void checkExec(String cmd); if cmd is an absolute path:java.io.FilePermission "{cmd}", "execute";
    else java.io.FilePermission "-", "execute";
    public void checkExit(int status); java.lang.RuntimePermission "exitVM");
    public void checkLink(String lib); java.lang.RuntimePermission "loadLibrary.{lib}";
    public void checkListen(int port); if (port == 0) java.net.SocketPermission "localhost:1024-","listen";
    else java.net.SocketPermission "localhost:{port}","listen";
    public void checkMemberAccess(Class clazz, int which); 
    if (which != Member.PUBLIC) {
if (currentClassLoader() != clazz.getClassLoader()) {
checkPermission(
new java.lang.RuntimePermission("accessDeclaredMembers"));
  }
}
    public void checkMulticast(InetAddress maddr); java.net.SocketPermission(maddr.getHostAddress(),"accept,connect");
    public void checkMulticast(InetAddress maddr, byte ttl); java.net.SocketPermission(maddr.getHostAddress(),"accept,connect");
    public void checkPackageAccess(String pkg); java.lang.RuntimePermission "accessClassInPackage.{pkg}";
    public void checkPackageDefinition(String pkg); java.lang.RuntimePermission "defineClassInPackage.{pkg}";
    public void checkPrintJobAccess(); java.lang.RuntimePermission "queuePrintJob";
    public void checkPropertiesAccess(); java.util.PropertyPermission "*", "read,write";
    public void checkPropertyAccess(String key); java.util.PropertyPermission "{key}", "read,write";
    public void checkRead(FileDescriptor fd); java.lang.RuntimePermission "readFileDescriptor";
    public void checkRead(String file); java.io.FilePermission "{file}", "read";
    public void checkRead(String file, Object context); java.io.FilePermission "{file}", "read";
    public void checkSecurityAccess(String action); java.security.SecurityPermission "{action}";
    public void checkSetFactory(); java.lang.RuntimePermission "setFactory";
    public void checkSystemClipboardAccess(); java.awt.AWTPermission "accessClipboard";
    public boolean checkTopLevelWindow(Object window); java.awt.AWTPermission "showWindowWithoutWarningBanner";
    public void checkWrite(FileDescriptor fd); java.lang.RuntimePermission "writeFileDescriptor";
    public void checkWrite(String file); java.io.FilePermission "{file}", "write";
    public SecurityManager(); java.lang.RuntimePermission "createSecurityManager";

    Copyright © 1997-2002 Sun Microsystems, Inc.All Rights Reserved.

    コメントの送付先: java-security@sun.com

    		 Sun
    Java ソフトウェア