Home | History | Annotate | Download | only in symmetric 
      1 package org.bouncycastle.jcajce.provider.symmetric;
      2 
      3 import java.io.IOException;
      4 import java.security.AlgorithmParameters;
      5 import java.security.InvalidAlgorithmParameterException;
      6 import java.security.SecureRandom;
      7 import java.security.spec.AlgorithmParameterSpec;
      8 import java.security.spec.InvalidParameterSpecException;
      9 
     10 import javax.crypto.spec.IvParameterSpec;
     11 import javax.crypto.spec.RC2ParameterSpec;
     12 
     13 import org.bouncycastle.asn1.ASN1Primitive;
     14 import org.bouncycastle.asn1.pkcs.PKCSObjectIdentifiers;
     15 // Android-removed: Unsupported algorithms
     16 // import org.bouncycastle.asn1.pkcs.RC2CBCParameter;
     17 // import org.bouncycastle.crypto.CipherKeyGenerator;
     18 import org.bouncycastle.crypto.engines.RC2Engine;
     19 // Android-removed: Unsupported algorithms
     20 // import org.bouncycastle.crypto.engines.RC2WrapEngine;
     21 // import org.bouncycastle.crypto.macs.CBCBlockCipherMac;
     22 // import org.bouncycastle.crypto.macs.CFBBlockCipherMac;
     23 import org.bouncycastle.crypto.modes.CBCBlockCipher;
     24 import org.bouncycastle.jcajce.provider.config.ConfigurableProvider;
     25 // Android-removed: Unsupported algorithms
     26 // import org.bouncycastle.jcajce.provider.symmetric.util.BaseAlgorithmParameterGenerator;
     27 // import org.bouncycastle.jcajce.provider.symmetric.util.BaseAlgorithmParameters;
     28 import org.bouncycastle.jcajce.provider.symmetric.util.BaseBlockCipher;
     29 // Android-removed: Unsupported algorithms
     30 // import org.bouncycastle.jcajce.provider.symmetric.util.BaseKeyGenerator;
     31 // import org.bouncycastle.jcajce.provider.symmetric.util.BaseMac;
     32 // import org.bouncycastle.jcajce.provider.symmetric.util.BaseWrapCipher;
     33 import org.bouncycastle.jcajce.provider.symmetric.util.PBESecretKeyFactory;
     34 import org.bouncycastle.jcajce.provider.util.AlgorithmProvider;
     35 import org.bouncycastle.util.Arrays;
     36 
     37 public final class RC2
     38 {
     39     private RC2()
     40     {
     41     }
     42 
     43     // BEGIN Android-removed: Unsupported algorithms
     44     /*
     45     /**
     46      * RC2
     47      *
     48     static public class ECB
     49         extends BaseBlockCipher
     50     {
     51         public ECB()
     52         {
     53             super(new RC2Engine());
     54         }
     55     }
     56 
     57     /**
     58      * RC2CBC
     59      *
     60     static public class CBC
     61         extends BaseBlockCipher
     62     {
     63         public CBC()
     64         {
     65             super(new CBCBlockCipher(new RC2Engine()), 64);
     66         }
     67     }
     68 
     69     public static class Wrap
     70         extends BaseWrapCipher
     71     {
     72         public Wrap()
     73         {
     74             super(new RC2WrapEngine());
     75         }
     76     }
     77 
     78     /**
     79      * RC2
     80      *
     81     public static class CBCMAC
     82         extends BaseMac
     83     {
     84         public CBCMAC()
     85         {
     86             super(new CBCBlockCipherMac(new RC2Engine()));
     87         }
     88     }
     89 
     90     public static class CFB8MAC
     91         extends BaseMac
     92     {
     93         public CFB8MAC()
     94         {
     95             super(new CFBBlockCipherMac(new RC2Engine()));
     96         }
     97     }
     98     */
     99     // END Android-removed: Unsupported algorithms
    100 
    101     /**
    102      * PBEWithSHA1AndRC2
    103      */
    104     static public class PBEWithSHA1KeyFactory
    105         extends PBESecretKeyFactory
    106     {
    107         public PBEWithSHA1KeyFactory()
    108         {
    109             super("PBEwithSHA1andRC2", PKCSObjectIdentifiers.pbeWithSHA1AndRC2_CBC, true, PKCS5S1, SHA1, 64, 64);
    110         }
    111     }
    112 
    113     /**
    114      * PBEWithSHAAnd128BitRC2-CBC
    115      */
    116     static public class PBEWithSHAAnd128BitKeyFactory
    117         extends PBESecretKeyFactory
    118     {
    119         public PBEWithSHAAnd128BitKeyFactory()
    120         {
    121             super("PBEwithSHAand128BitRC2-CBC", PKCSObjectIdentifiers.pbeWithSHAAnd128BitRC2_CBC, true, PKCS12, SHA1, 128, 64);
    122         }
    123     }
    124 
    125     /**
    126      * PBEWithSHAAnd40BitRC2-CBC
    127      */
    128     static public class PBEWithSHAAnd40BitKeyFactory
    129         extends PBESecretKeyFactory
    130     {
    131         public PBEWithSHAAnd40BitKeyFactory()
    132         {
    133             super("PBEwithSHAand40BitRC2-CBC", PKCSObjectIdentifiers.pbeWithSHAAnd40BitRC2_CBC, true, PKCS12, SHA1, 40, 64);
    134         }
    135     }
    136 
    137     /**
    138      * PBEWithMD5AndRC2
    139      */
    140     static public class PBEWithMD5AndRC2
    141         extends BaseBlockCipher
    142     {
    143         public PBEWithMD5AndRC2()
    144         {
    145             super(new CBCBlockCipher(new RC2Engine()), PKCS5S1, MD5, 64, 8);
    146         }
    147     }
    148 
    149     /**
    150      * PBEWithSHA1AndRC2
    151      */
    152     static public class PBEWithSHA1AndRC2
    153         extends BaseBlockCipher
    154     {
    155         public PBEWithSHA1AndRC2()
    156         {
    157             super(new CBCBlockCipher(new RC2Engine()), PKCS5S1, SHA1, 64, 8);
    158         }
    159     }
    160 
    161     /**
    162      * PBEWithSHAAnd128BitRC2-CBC
    163      */
    164     static public class PBEWithSHAAnd128BitRC2
    165         extends BaseBlockCipher
    166     {
    167         public PBEWithSHAAnd128BitRC2()
    168         {
    169             super(new CBCBlockCipher(new RC2Engine()), PKCS12, SHA1, 128, 8);
    170         }
    171     }
    172 
    173     /**
    174      * PBEWithSHAAnd40BitRC2-CBC
    175      */
    176     static public class PBEWithSHAAnd40BitRC2
    177         extends BaseBlockCipher
    178     {
    179         public PBEWithSHAAnd40BitRC2()
    180         {
    181             super(new CBCBlockCipher(new RC2Engine()), PKCS12, SHA1, 40, 8);
    182         }
    183     }
    184 
    185     // BEGIN Android-removed: Unsupported algorithms
    186     /*
    187     /**
    188      * PBEWithMD2AndRC2
    189      *
    190     static public class PBEWithMD2KeyFactory
    191         extends PBESecretKeyFactory
    192     {
    193         public PBEWithMD2KeyFactory()
    194         {
    195             super("PBEwithMD2andRC2", PKCSObjectIdentifiers.pbeWithMD2AndRC2_CBC, true, PKCS5S1, MD2, 64, 64);
    196         }
    197     }
    198     */
    199     // END Android-removed: Unsupported algorithms
    200 
    201    /**
    202     * PBEWithMD5AndRC2
    203     */
    204    static public class PBEWithMD5KeyFactory
    205        extends PBESecretKeyFactory
    206    {
    207        public PBEWithMD5KeyFactory()
    208        {
    209            super("PBEwithMD5andRC2", PKCSObjectIdentifiers.pbeWithMD5AndRC2_CBC, true, PKCS5S1, MD5, 64, 64);
    210        }
    211    }
    212 
    213     // BEGIN Android-removed: Unsupported algorithms
    214     /*
    215     public static class AlgParamGen
    216         extends BaseAlgorithmParameterGenerator
    217     {
    218         RC2ParameterSpec spec = null;
    219 
    220         protected void engineInit(
    221             AlgorithmParameterSpec genParamSpec,
    222             SecureRandom random)
    223             throws InvalidAlgorithmParameterException
    224         {
    225             if (genParamSpec instanceof RC2ParameterSpec)
    226             {
    227                 spec = (RC2ParameterSpec)genParamSpec;
    228                 return;
    229             }
    230 
    231             throw new InvalidAlgorithmParameterException("No supported AlgorithmParameterSpec for RC2 parameter generation.");
    232         }
    233 
    234         protected AlgorithmParameters engineGenerateParameters()
    235         {
    236             AlgorithmParameters params;
    237 
    238             if (spec == null)
    239             {
    240                 byte[] iv = new byte[8];
    241 
    242                 if (random == null)
    243                 {
    244                     random = new SecureRandom();
    245                 }
    246 
    247                 random.nextBytes(iv);
    248 
    249                 try
    250                 {
    251                     params = createParametersInstance("RC2");
    252                     params.init(new IvParameterSpec(iv));
    253                 }
    254                 catch (Exception e)
    255                 {
    256                     throw new RuntimeException(e.getMessage());
    257                 }
    258             }
    259             else
    260             {
    261                 try
    262                 {
    263                     params = createParametersInstance("RC2");
    264                     params.init(spec);
    265                 }
    266                 catch (Exception e)
    267                 {
    268                     throw new RuntimeException(e.getMessage());
    269                 }
    270             }
    271 
    272             return params;
    273         }
    274     }
    275 
    276     public static class KeyGenerator
    277         extends BaseKeyGenerator
    278     {
    279         public KeyGenerator()
    280         {
    281             super("RC2", 128, new CipherKeyGenerator());
    282         }
    283     }
    284 
    285     public static class AlgParams
    286         extends BaseAlgorithmParameters
    287     {
    288         private static final short[] table = {
    289             0xbd, 0x56, 0xea, 0xf2, 0xa2, 0xf1, 0xac, 0x2a, 0xb0, 0x93, 0xd1, 0x9c, 0x1b, 0x33, 0xfd, 0xd0,
    290             0x30, 0x04, 0xb6, 0xdc, 0x7d, 0xdf, 0x32, 0x4b, 0xf7, 0xcb, 0x45, 0x9b, 0x31, 0xbb, 0x21, 0x5a,
    291             0x41, 0x9f, 0xe1, 0xd9, 0x4a, 0x4d, 0x9e, 0xda, 0xa0, 0x68, 0x2c, 0xc3, 0x27, 0x5f, 0x80, 0x36,
    292             0x3e, 0xee, 0xfb, 0x95, 0x1a, 0xfe, 0xce, 0xa8, 0x34, 0xa9, 0x13, 0xf0, 0xa6, 0x3f, 0xd8, 0x0c,
    293             0x78, 0x24, 0xaf, 0x23, 0x52, 0xc1, 0x67, 0x17, 0xf5, 0x66, 0x90, 0xe7, 0xe8, 0x07, 0xb8, 0x60,
    294             0x48, 0xe6, 0x1e, 0x53, 0xf3, 0x92, 0xa4, 0x72, 0x8c, 0x08, 0x15, 0x6e, 0x86, 0x00, 0x84, 0xfa,
    295             0xf4, 0x7f, 0x8a, 0x42, 0x19, 0xf6, 0xdb, 0xcd, 0x14, 0x8d, 0x50, 0x12, 0xba, 0x3c, 0x06, 0x4e,
    296             0xec, 0xb3, 0x35, 0x11, 0xa1, 0x88, 0x8e, 0x2b, 0x94, 0x99, 0xb7, 0x71, 0x74, 0xd3, 0xe4, 0xbf,
    297             0x3a, 0xde, 0x96, 0x0e, 0xbc, 0x0a, 0xed, 0x77, 0xfc, 0x37, 0x6b, 0x03, 0x79, 0x89, 0x62, 0xc6,
    298             0xd7, 0xc0, 0xd2, 0x7c, 0x6a, 0x8b, 0x22, 0xa3, 0x5b, 0x05, 0x5d, 0x02, 0x75, 0xd5, 0x61, 0xe3,
    299             0x18, 0x8f, 0x55, 0x51, 0xad, 0x1f, 0x0b, 0x5e, 0x85, 0xe5, 0xc2, 0x57, 0x63, 0xca, 0x3d, 0x6c,
    300             0xb4, 0xc5, 0xcc, 0x70, 0xb2, 0x91, 0x59, 0x0d, 0x47, 0x20, 0xc8, 0x4f, 0x58, 0xe0, 0x01, 0xe2,
    301             0x16, 0x38, 0xc4, 0x6f, 0x3b, 0x0f, 0x65, 0x46, 0xbe, 0x7e, 0x2d, 0x7b, 0x82, 0xf9, 0x40, 0xb5,
    302             0x1d, 0x73, 0xf8, 0xeb, 0x26, 0xc7, 0x87, 0x97, 0x25, 0x54, 0xb1, 0x28, 0xaa, 0x98, 0x9d, 0xa5,
    303             0x64, 0x6d, 0x7a, 0xd4, 0x10, 0x81, 0x44, 0xef, 0x49, 0xd6, 0xae, 0x2e, 0xdd, 0x76, 0x5c, 0x2f,
    304             0xa7, 0x1c, 0xc9, 0x09, 0x69, 0x9a, 0x83, 0xcf, 0x29, 0x39, 0xb9, 0xe9, 0x4c, 0xff, 0x43, 0xab
    305         };
    306 
    307         private static final short[] ekb = {
    308             0x5d, 0xbe, 0x9b, 0x8b, 0x11, 0x99, 0x6e, 0x4d, 0x59, 0xf3, 0x85, 0xa6, 0x3f, 0xb7, 0x83, 0xc5,
    309             0xe4, 0x73, 0x6b, 0x3a, 0x68, 0x5a, 0xc0, 0x47, 0xa0, 0x64, 0x34, 0x0c, 0xf1, 0xd0, 0x52, 0xa5,
    310             0xb9, 0x1e, 0x96, 0x43, 0x41, 0xd8, 0xd4, 0x2c, 0xdb, 0xf8, 0x07, 0x77, 0x2a, 0xca, 0xeb, 0xef,
    311             0x10, 0x1c, 0x16, 0x0d, 0x38, 0x72, 0x2f, 0x89, 0xc1, 0xf9, 0x80, 0xc4, 0x6d, 0xae, 0x30, 0x3d,
    312             0xce, 0x20, 0x63, 0xfe, 0xe6, 0x1a, 0xc7, 0xb8, 0x50, 0xe8, 0x24, 0x17, 0xfc, 0x25, 0x6f, 0xbb,
    313             0x6a, 0xa3, 0x44, 0x53, 0xd9, 0xa2, 0x01, 0xab, 0xbc, 0xb6, 0x1f, 0x98, 0xee, 0x9a, 0xa7, 0x2d,
    314             0x4f, 0x9e, 0x8e, 0xac, 0xe0, 0xc6, 0x49, 0x46, 0x29, 0xf4, 0x94, 0x8a, 0xaf, 0xe1, 0x5b, 0xc3,
    315             0xb3, 0x7b, 0x57, 0xd1, 0x7c, 0x9c, 0xed, 0x87, 0x40, 0x8c, 0xe2, 0xcb, 0x93, 0x14, 0xc9, 0x61,
    316             0x2e, 0xe5, 0xcc, 0xf6, 0x5e, 0xa8, 0x5c, 0xd6, 0x75, 0x8d, 0x62, 0x95, 0x58, 0x69, 0x76, 0xa1,
    317             0x4a, 0xb5, 0x55, 0x09, 0x78, 0x33, 0x82, 0xd7, 0xdd, 0x79, 0xf5, 0x1b, 0x0b, 0xde, 0x26, 0x21,
    318             0x28, 0x74, 0x04, 0x97, 0x56, 0xdf, 0x3c, 0xf0, 0x37, 0x39, 0xdc, 0xff, 0x06, 0xa4, 0xea, 0x42,
    319             0x08, 0xda, 0xb4, 0x71, 0xb0, 0xcf, 0x12, 0x7a, 0x4e, 0xfa, 0x6c, 0x1d, 0x84, 0x00, 0xc8, 0x7f,
    320             0x91, 0x45, 0xaa, 0x2b, 0xc2, 0xb1, 0x8f, 0xd5, 0xba, 0xf2, 0xad, 0x19, 0xb2, 0x67, 0x36, 0xf7,
    321             0x0f, 0x0a, 0x92, 0x7d, 0xe3, 0x9d, 0xe9, 0x90, 0x3e, 0x23, 0x27, 0x66, 0x13, 0xec, 0x81, 0x15,
    322             0xbd, 0x22, 0xbf, 0x9f, 0x7e, 0xa9, 0x51, 0x4b, 0x4c, 0xfb, 0x02, 0xd3, 0x70, 0x86, 0x31, 0xe7,
    323             0x3b, 0x05, 0x03, 0x54, 0x60, 0x48, 0x65, 0x18, 0xd2, 0xcd, 0x5f, 0x32, 0x88, 0x0e, 0x35, 0xfd
    324         };
    325 
    326         private byte[] iv;
    327         private int parameterVersion = 58;
    328 
    329         protected byte[] engineGetEncoded()
    330         {
    331             return Arrays.clone(iv);
    332         }
    333 
    334         protected byte[] engineGetEncoded(
    335             String format)
    336             throws IOException
    337         {
    338             if (this.isASN1FormatString(format))
    339             {
    340                 if (parameterVersion == -1)
    341                 {
    342                     return new RC2CBCParameter(engineGetEncoded()).getEncoded();
    343                 }
    344                 else
    345                 {
    346                     return new RC2CBCParameter(parameterVersion, engineGetEncoded()).getEncoded();
    347                 }
    348             }
    349 
    350             if (format.equals("RAW"))
    351             {
    352                 return engineGetEncoded();
    353             }
    354 
    355             return null;
    356         }
    357 
    358         protected AlgorithmParameterSpec localEngineGetParameterSpec(
    359             Class paramSpec)
    360             throws InvalidParameterSpecException
    361         {
    362             if (paramSpec == RC2ParameterSpec.class || paramSpec == AlgorithmParameterSpec.class)
    363             {
    364                 if (parameterVersion != -1)
    365                 {
    366                     if (parameterVersion < 256)
    367                     {
    368                         return new RC2ParameterSpec(ekb[parameterVersion], iv);
    369                     }
    370                     else
    371                     {
    372                         return new RC2ParameterSpec(parameterVersion, iv);
    373                     }
    374                 }
    375             }
    376 
    377             if (paramSpec == IvParameterSpec.class || paramSpec == AlgorithmParameterSpec.class)
    378             {
    379                 return new IvParameterSpec(iv);
    380             }
    381 
    382             throw new InvalidParameterSpecException("unknown parameter spec passed to RC2 parameters object.");
    383         }
    384 
    385         protected void engineInit(
    386             AlgorithmParameterSpec paramSpec)
    387             throws InvalidParameterSpecException
    388         {
    389             if (paramSpec instanceof IvParameterSpec)
    390             {
    391                 this.iv = ((IvParameterSpec)paramSpec).getIV();
    392             }
    393             else if (paramSpec instanceof RC2ParameterSpec)
    394             {
    395                 int effKeyBits = ((RC2ParameterSpec)paramSpec).getEffectiveKeyBits();
    396                 if (effKeyBits != -1)
    397                 {
    398                     if (effKeyBits < 256)
    399                     {
    400                         parameterVersion = table[effKeyBits];
    401                     }
    402                     else
    403                     {
    404                         parameterVersion = effKeyBits;
    405                     }
    406                 }
    407 
    408                 this.iv = ((RC2ParameterSpec)paramSpec).getIV();
    409             }
    410             else
    411             {
    412                 throw new InvalidParameterSpecException("IvParameterSpec or RC2ParameterSpec required to initialise a RC2 parameters algorithm parameters object");
    413             }
    414         }
    415 
    416         protected void engineInit(
    417             byte[] params)
    418             throws IOException
    419         {
    420             this.iv = Arrays.clone(params);
    421         }
    422 
    423         protected void engineInit(
    424             byte[] params,
    425             String format)
    426             throws IOException
    427         {
    428             if (this.isASN1FormatString(format))
    429             {
    430                 RC2CBCParameter p = RC2CBCParameter.getInstance(ASN1Primitive.fromByteArray(params));
    431 
    432                 if (p.getRC2ParameterVersion() != null)
    433                 {
    434                     parameterVersion = p.getRC2ParameterVersion().intValue();
    435                 }
    436 
    437                 iv = p.getIV();
    438 
    439                 return;
    440             }
    441 
    442             if (format.equals("RAW"))
    443             {
    444                 engineInit(params);
    445                 return;
    446             }
    447 
    448             throw new IOException("Unknown parameters format in IV parameters object");
    449         }
    450 
    451         protected String engineToString()
    452         {
    453             return "RC2 Parameters";
    454         }
    455     }
    456     */
    457     // END Android-removed: Unsupported algorithms
    458 
    459     public static class Mappings
    460         extends AlgorithmProvider
    461     {
    462         private static final String PREFIX = RC2.class.getName();
    463 
    464         public Mappings()
    465         {
    466         }
    467 
    468         public void configure(ConfigurableProvider provider)
    469         {
    470 
    471             // BEGIN Android-removed: Unsupported algorithms
    472             /*
    473             provider.addAlgorithm("AlgorithmParameterGenerator.RC2", PREFIX + "$AlgParamGen");
    474             provider.addAlgorithm("AlgorithmParameterGenerator.1.2.840.113549.3.2", PREFIX + "$AlgParamGen");
    475 
    476             provider.addAlgorithm("KeyGenerator.RC2", PREFIX + "$KeyGenerator");
    477             provider.addAlgorithm("KeyGenerator.1.2.840.113549.3.2", PREFIX + "$KeyGenerator");
    478 
    479             provider.addAlgorithm("AlgorithmParameters.RC2", PREFIX + "$AlgParams");
    480             provider.addAlgorithm("AlgorithmParameters.1.2.840.113549.3.2", PREFIX + "$AlgParams");
    481 
    482             provider.addAlgorithm("Cipher.RC2", PREFIX + "$ECB");
    483             provider.addAlgorithm("Cipher.RC2WRAP", PREFIX + "$Wrap");
    484             provider.addAlgorithm("Alg.Alias.Cipher", PKCSObjectIdentifiers.id_alg_CMSRC2wrap, "RC2WRAP");
    485             provider.addAlgorithm("Cipher", PKCSObjectIdentifiers.RC2_CBC, PREFIX + "$CBC");
    486 
    487             provider.addAlgorithm("Mac.RC2MAC", PREFIX + "$CBCMAC");
    488             provider.addAlgorithm("Alg.Alias.Mac.RC2", "RC2MAC");
    489             provider.addAlgorithm("Mac.RC2MAC/CFB8", PREFIX + "$CFB8MAC");
    490             provider.addAlgorithm("Alg.Alias.Mac.RC2/CFB8", "RC2MAC/CFB8");
    491 
    492             provider.addAlgorithm("Alg.Alias.SecretKeyFactory.PBEWITHMD2ANDRC2-CBC", "PBEWITHMD2ANDRC2");
    493             */
    494             // END Android-removed: Unsupported algorithms
    495 
    496             // Android-note: All of the non-disabled algorithms in this class are necessary
    497             // for KeyStore.PKCS12
    498             provider.addAlgorithm("Alg.Alias.SecretKeyFactory.PBEWITHMD5ANDRC2-CBC", "PBEWITHMD5ANDRC2");
    499 
    500             provider.addAlgorithm("Alg.Alias.SecretKeyFactory.PBEWITHSHA1ANDRC2-CBC", "PBEWITHSHA1ANDRC2");
    501 
    502             // Android-removed: Unsupported algorithms
    503             // provider.addAlgorithm("Alg.Alias.SecretKeyFactory", PKCSObjectIdentifiers.pbeWithMD2AndRC2_CBC, "PBEWITHMD2ANDRC2");
    504 
    505             provider.addAlgorithm("Alg.Alias.SecretKeyFactory", PKCSObjectIdentifiers.pbeWithMD5AndRC2_CBC, "PBEWITHMD5ANDRC2");
    506 
    507             provider.addAlgorithm("Alg.Alias.SecretKeyFactory", PKCSObjectIdentifiers.pbeWithSHA1AndRC2_CBC, "PBEWITHSHA1ANDRC2");
    508             provider.addAlgorithm("Alg.Alias.SecretKeyFactory.1.2.840.113549.1.12.1.5", "PBEWITHSHAAND128BITRC2-CBC");
    509             provider.addAlgorithm("Alg.Alias.SecretKeyFactory.1.2.840.113549.1.12.1.6", "PBEWITHSHAAND40BITRC2-CBC");
    510 
    511             // Android-removed: Unsupported algorithms
    512             // provider.addAlgorithm("SecretKeyFactory.PBEWITHMD2ANDRC2", PREFIX + "$PBEWithMD2KeyFactory");
    513             provider.addAlgorithm("SecretKeyFactory.PBEWITHMD5ANDRC2", PREFIX + "$PBEWithMD5KeyFactory");
    514             provider.addAlgorithm("SecretKeyFactory.PBEWITHSHA1ANDRC2", PREFIX + "$PBEWithSHA1KeyFactory");
    515 
    516             provider.addAlgorithm("SecretKeyFactory.PBEWITHSHAAND128BITRC2-CBC", PREFIX + "$PBEWithSHAAnd128BitKeyFactory");
    517             provider.addAlgorithm("SecretKeyFactory.PBEWITHSHAAND40BITRC2-CBC", PREFIX + "$PBEWithSHAAnd40BitKeyFactory");
    518 
    519             // Android-removed: Unsupported algorithms
    520             // provider.addAlgorithm("Alg.Alias.Cipher", PKCSObjectIdentifiers.pbeWithMD2AndRC2_CBC, "PBEWITHMD2ANDRC2");
    521 
    522             provider.addAlgorithm("Alg.Alias.Cipher", PKCSObjectIdentifiers.pbeWithMD5AndRC2_CBC, "PBEWITHMD5ANDRC2");
    523 
    524             provider.addAlgorithm("Alg.Alias.Cipher", PKCSObjectIdentifiers.pbeWithSHA1AndRC2_CBC, "PBEWITHSHA1ANDRC2");
    525 
    526             provider.addAlgorithm("Alg.Alias.AlgorithmParameters.1.2.840.113549.1.12.1.5", "PKCS12PBE");
    527             provider.addAlgorithm("Alg.Alias.AlgorithmParameters.1.2.840.113549.1.12.1.6", "PKCS12PBE");
    528             provider.addAlgorithm("Alg.Alias.AlgorithmParameters.PBEWithSHAAnd3KeyTripleDES", "PKCS12PBE");
    529 
    530             provider.addAlgorithm("Alg.Alias.Cipher", PKCSObjectIdentifiers.pbeWithSHAAnd128BitRC2_CBC, "PBEWITHSHAAND128BITRC2-CBC");
    531             provider.addAlgorithm("Alg.Alias.Cipher", PKCSObjectIdentifiers.pbeWithSHAAnd40BitRC2_CBC, "PBEWITHSHAAND40BITRC2-CBC");
    532             provider.addAlgorithm("Alg.Alias.Cipher.PBEWITHSHA1AND128BITRC2-CBC", "PBEWITHSHAAND128BITRC2-CBC");
    533             provider.addAlgorithm("Alg.Alias.Cipher.PBEWITHSHA1AND40BITRC2-CBC", "PBEWITHSHAAND40BITRC2-CBC");
    534             provider.addAlgorithm("Cipher.PBEWITHSHA1ANDRC2", PREFIX + "$PBEWithSHA1AndRC2");
    535             provider.addAlgorithm("Alg.Alias.Cipher.PBEWITHSHAANDRC2-CBC", "PBEWITHSHA1ANDRC2");
    536             provider.addAlgorithm("Alg.Alias.Cipher.PBEWITHSHA1ANDRC2-CBC", "PBEWITHSHA1ANDRC2");
    537 
    538             provider.addAlgorithm("Cipher.PBEWITHSHAAND128BITRC2-CBC", PREFIX + "$PBEWithSHAAnd128BitRC2");
    539             provider.addAlgorithm("Cipher.PBEWITHSHAAND40BITRC2-CBC", PREFIX + "$PBEWithSHAAnd40BitRC2");
    540             provider.addAlgorithm("Cipher.PBEWITHMD5ANDRC2", PREFIX + "$PBEWithMD5AndRC2");
    541             provider.addAlgorithm("Alg.Alias.Cipher.PBEWITHMD5ANDRC2-CBC", "PBEWITHMD5ANDRC2");
    542 
    543             provider.addAlgorithm("Alg.Alias.AlgorithmParameters.PBEWITHSHA1ANDRC2", "PKCS12PBE");
    544             provider.addAlgorithm("Alg.Alias.AlgorithmParameters.PBEWITHSHAANDRC2", "PKCS12PBE");
    545             provider.addAlgorithm("Alg.Alias.AlgorithmParameters.PBEWITHSHA1ANDRC2-CBC", "PKCS12PBE");
    546             provider.addAlgorithm("Alg.Alias.AlgorithmParameters.PBEWITHSHAAND40BITRC2-CBC", "PKCS12PBE");
    547             provider.addAlgorithm("Alg.Alias.AlgorithmParameters.PBEWITHSHAAND128BITRC2-CBC", "PKCS12PBE");
    548         }
    549     }
    550 }
    551