/** * Set if this mechanism can be used for decryption. * * @param decrypt * True, if this mechanism can be used for decryption. * @preconditions * @postconditions */ public void setDecrypt(boolean decrypt) { setFlagBit(PKCS11Constants.CKF_DECRYPT, decrypt); }
/** * Set if this mechanism can be used with EC domain parameters over Fp. * * @param ecFp * True, if this mechanism can be used with EC domain parameters * over Fp. * @preconditions * @postconditions */ public void setEcFp(boolean ecFp) { setFlagBit(PKCS11Constants.CKF_EC_F_P, ecFp); }
/** * Set if this mechanism can be used for key-pair generation. * * @param generateKeyPair * True, if this mechanism can be used for key-pair generation. * @preconditions * @postconditions */ public void setGenerateKeyPair(boolean generateKeyPair) { setFlagBit(PKCS11Constants.CKF_GENERATE_KEY_PAIR, generateKeyPair); }
/** * Set if this mechanism can be used with EC domain parameters over F2m. * * @param ecF2m * True, if this mechanism can be used with EC domain parameters * over F2m. * @preconditions * @postconditions */ public void setEcF2m(boolean ecF2m) { setFlagBit(PKCS11Constants.CKF_EC_F_2M, ecF2m); }
/** * Set if this mechanism can be used for verification. * * @param verfy * True, if this mechanism can be used for verification. * @preconditions * @postconditions */ public void setVerify(boolean verfy) { setFlagBit(PKCS11Constants.CKF_VERIFY, verfy); }
/** * Set if this mechanism can be used for secret key generation. * * @param generate * True, if this mechanism can be used for secret key generation. * @preconditions * @postconditions */ public void setGenerate(boolean generate) { setFlagBit(PKCS11Constants.CKF_GENERATE, generate); }
/** * Set if this mechanism can be used for key derivation. * * @param derive * True, if this mechanism can be used for key derivation. * @preconditions * @postconditions */ public void setDerive(boolean derive) { setFlagBit(PKCS11Constants.CKF_DERIVE, derive); }
/** * Set, if this mechanism is performed in hardware. * * @param hw * True, if this mechanism is performed in hardware. * @preconditions * @postconditions */ public void setHw(boolean hw) { setFlagBit(PKCS11Constants.CKF_HW, hw); }
/** * Set if this mechanism can be used for encryption. * * @param encrypt * True, if this mechanism can be used for encryption. * @preconditions * @postconditions */ public void setEncrypt(boolean encrypt) { setFlagBit(PKCS11Constants.CKF_ENCRYPT, encrypt); }
/** * Set if this mechanism can be used for key unwrapping. * * @param unwrap * True, if this mechanism can be used for key unwrapping. * @preconditions * @postconditions */ public void setUnwrap(boolean unwrap) { setFlagBit(PKCS11Constants.CKF_UNWRAP, unwrap); }
/** * Set if this mechanism can be used with elliptic curve point compressed. * * @param ecCompress * True, if this mechanism can be used with elliptic curve point * compressed. * @preconditions * @postconditions */ public void setEcCompress(boolean ecCompress) { setFlagBit(PKCS11Constants.CKF_EC_COMPRESS, ecCompress); }
/** * Set if there is an extension to the flags; false, if no extensions. * Must be false for this version. * * @param extension * False for this version. * @preconditions * @postconditions */ public void setExtension(boolean extension) { setFlagBit(PKCS11Constants.CKF_EXTENSION, extension); }
/** * Set if this mechanism can be used with EC domain parameters of the * choice ecParameters. * * @param ecEcParameters * True, if this mechanism can be used with EC domain parameters of * the choice ecParameters. * @preconditions * @postconditions */ public void setEcEcParameters(boolean ecEcParameters) { setFlagBit(PKCS11Constants.CKF_EC_ECPARAMETERS, ecEcParameters); }
/** * Set if this mechanism can be used for digesting. * * @param digest * True, if this mechanism can be used for digesting. * @preconditions * @postconditions */ public void setDigest(boolean digest) { setFlagBit(PKCS11Constants.CKF_DIGEST, digest); }
/** * Set if this mechanism can be used for signing. * * @param sign * True, if this mechanism can be used for signing. * @preconditions * @postconditions */ public void setSign(boolean sign) { setFlagBit(PKCS11Constants.CKF_SIGN, sign); }
/** * Set if this mechanism can be used for signing with data recovery. * * @param signRecover * True, if this mechanism can be used for signing with data * recovery. * @preconditions * @postconditions */ public void setSignRecover(boolean signRecover) { setFlagBit(PKCS11Constants.CKF_SIGN_RECOVER, signRecover); }
/** * Set if this mechanism can be used for verification with data recovery. * * @param verifyRecover * True, if this mechanism can be used for verification with data * recovery. * @preconditions * @postconditions */ public void setVerifyRecover(boolean verifyRecover) { setFlagBit(PKCS11Constants.CKF_VERIFY_RECOVER, verifyRecover); }
/** * Set if this mechanism can be used for key wrapping. * * @param wrap * True, if this mechanism can be used for key wrapping. * @preconditions * @postconditions */ public void setWrap(boolean wrap) { setFlagBit(PKCS11Constants.CKF_WRAP, wrap); }
/** * Set if this mechanism can be used with elliptic curve point * uncompressed. * * @param ecUncompress * True, if this mechanism can be used with elliptic curve point * uncompressed. * @preconditions * @postconditions */ public void setEcUncompress(boolean ecUncompress) { setFlagBit(PKCS11Constants.CKF_EC_UNCOMPRESS, ecUncompress); }
/** * Set if this mechanism can be used with EC domain parameters of the * choice namedCurve. * * @param ecNamedCurve * True, if this mechanism can be used with EC domain parameters of * the choice namedCurve. * @preconditions * @postconditions */ public void setEcNamedCurve(boolean ecNamedCurve) { setFlagBit(PKCS11Constants.CKF_EC_NAMEDCURVE, ecNamedCurve); }