libcore/support/src/test/java/tests/security/SignatureTest.java

   1 /*
   2  * Copyright (C) 2009 The Android Open Source Project
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *     http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16 package tests.security;
  17
  18 import dalvik.annotation.TestLevel;
  19 import dalvik.annotation.TestTargetNew;
  20 import dalvik.annotation.TestTargets;
  21
  22 import junit.framework.TestCase;
  23
  24 import java.security.InvalidKeyException;
  25 import java.security.KeyPair;
  26 import java.security.KeyPairGenerator;
  27 import java.security.NoSuchAlgorithmException;
  28 import java.security.PrivateKey;
  29 import java.security.PublicKey;
  30 import java.security.Signature;
  31 import java.security.SignatureException;
  32 public abstract class SignatureTest extends TestCase {
  33
  34     private final String algorithmName;
  35     private final String keyAlgorithmName;
  36     private static final String signData = "some data to sign an"; //d verify";
  37     KeyPairGenerator generator;
  38     KeyPair keyPair;
  39
  40     public SignatureTest(String algorithmName, String keyAlgorithmName) {
  41         this.algorithmName = algorithmName;
  42         this.keyAlgorithmName = keyAlgorithmName;
  43     }
  44
  45     protected void setUp() throws Exception {
  46         super.setUp();
  47         generator = getGenerator();
  48         keyPair = getKeyPair();
  49     }
  50
  51     private KeyPair getKeyPair() {
  52         return generator.generateKeyPair();
  53     }
  54
  55     private KeyPairGenerator getGenerator() {
  56         try {
  57             return KeyPairGenerator.getInstance(keyAlgorithmName);
  58         } catch (NoSuchAlgorithmException e) {
  59             fail(e.getMessage());
  60         }
  61         return null;
  62     }
  63
  64     @TestTargets({
  65         @TestTargetNew(
  66                 level = TestLevel.ADDITIONAL,
  67                 method = "getInstance",
  68                 args = {String.class}
  69         ),
  70         @TestTargetNew(
  71                 level = TestLevel.ADDITIONAL,
  72                 method = "initSign",
  73                 args = {PrivateKey.class}
  74         ),
  75         @TestTargetNew(
  76                 level = TestLevel.ADDITIONAL,
  77                 method = "update",
  78                 args = {byte[].class}
  79         ),
  80         @TestTargetNew(
  81                 level = TestLevel.ADDITIONAL,
  82                 method = "sign",
  83                 args = {}
  84         ),
  85         @TestTargetNew(
  86                 level = TestLevel.ADDITIONAL,
  87                 method = "initVerify",
  88                 args = {PublicKey.class}
  89         ),
  90         @TestTargetNew(
  91                 level = TestLevel.ADDITIONAL,
  92                 method = "verify",
  93                 args = {byte[].class}
  94         ),
  95         @TestTargetNew(
  96                 level = TestLevel.COMPLETE,
  97                 method = "method",
  98                 args = {}
  99         )
 100     })
 101     public void testSignature() {
 102         Signature signature = null;
 103         try {
 104             signature = Signature.getInstance(algorithmName);
 105         } catch (NoSuchAlgorithmException e) {
 106             fail(e.getMessage());
 107         }
 108
 109         try {
 110             signature.initSign(keyPair.getPrivate());
 111         } catch (InvalidKeyException e) {
 112             fail(e.getMessage());
 113         }
 114
 115         try {
 116             signature.update(signData.getBytes());
 117         } catch (SignatureException e) {
 118             fail(e.getMessage());
 119         }
 120
 121         byte[] sign = null;
 122         try {
 123             sign = signature.sign();
 124         } catch (SignatureException e) {
 125             fail(e.getMessage());
 126         }
 127
 128         try {
 129             signature.initVerify(keyPair.getPublic());
 130         } catch (InvalidKeyException e) {
 131             fail(e.getMessage());
 132         }
 133
 134         try {
 135             signature.update(signData.getBytes());
 136         } catch (SignatureException e) {
 137             fail(e.getMessage());
 138         }
 139
 140         try {
 141             assertTrue(signature.verify(sign));
 142         } catch (SignatureException e) {
 143             fail(e.getMessage());
 144         }
 145     }
 146 }