tcl_tests/smimeenc.try

   1 #!/usr/bin/tclsh
   2 # -*- coding: cp1251 -*-
   3 lappend auto_path [file dirname [info script]]
   4 package require ossltest
   5 cd $::test::dir
   6 set testname [file rootname [file tail $::argv0]]
   7
   8 start_tests "Тесты на smime -encrypt"
   9 proc make_fn {alg} {
  10         return [string map {":" "_"} $alg]
  11 }
  12
  13 proc map {str list} {
  14         set result {}
  15         foreach a $list {
  16                 lappend result [subst $str]
  17         }
  18         return $result
  19 }
  20 if {![file exist encrypt.dat]} {
  21         makeFile encrypt.dat [string repeat "Test data to encrypt.\n" 100]
  22 }
  23
  24 if {![info exist env(NO_RSA)]} {
  25 test "Creating RSA CA" {
  26         makeCA ${testname}CA-RSA rsa:512
  27 } 0 1
  28
  29 foreach user {U_enc_rsa_1 U_enc_rsa_2} {
  30 test "Make registered user $user" {
  31         makeRegisteredUser $user rsa:512 CAname ${testname}CA-RSA
  32 } 0 1
  33 }
  34
  35
  36 test "RSA User 1 encrypts message for RSA user 2" {
  37         openssl "smime -encrypt -in encrypt.dat -des -out enc_rsa.msg U_enc_rsa_2/cert.pem"
  38         file isfile enc_rsa.msg
  39 } 0 1
  40
  41 test "RSA User 1 cannot decrypt message for RSA user 2" {
  42         grep "Error"    [openssl "smime -decrypt -in enc_rsa.msg -recip U_enc_rsa_1/cert.pem -inkey U_enc_rsa_1/seckey.pem"]
  43 } 1 {Error decrypting PKCS#7 structure}
  44
  45 test -createsfiles decrypt.rsa "RSA User 2 (with cert) can decrypt message for RSA user 2" {
  46         set expected [getFile encrypt.dat]
  47         openssl "smime -decrypt -in enc_rsa.msg -recip U_enc_rsa_2/cert.pem -inkey U_enc_rsa_2/seckey.pem -out decrypt.rsa"
  48         set result [getFile decrypt.rsa]
  49         string eq $expected $result
  50 } 0 1
  51
  52 test -createsfiles decrypt_nocert.rsa "RSA User 2 (without cert) can decrypt message for RSA user 2" {
  53         set expected [getFile encrypt.dat]
  54         openssl "smime -decrypt -in enc_rsa.msg -inkey U_enc_rsa_2/seckey.pem -out decrypt_nocert.rsa"
  55         set result [getFile decrypt_nocert.rsa]
  56         string eq $expected $result
  57 } 0 1
  58 }
  59
  60 test "Creating CA 2001" {
  61         makeCA ${testname}CA gost2001:A
  62 } 0 1
  63
  64 test "Creating CA 2012" {
  65         makeCA
  66 } 0 1
  67
  68 if {[info exist env(ENC_LIST)]} {
  69         set enc_list $env(ENC_LIST)
  70 } else {
  71         switch -exact [engine_name] {
  72                 "ccore" {set enc_list {gost2001:XA:1.2.643.2.2.31.3 gost2001:XB:1.2.643.2.2.31.4 gost2001:XA: gost2012_256:XA:1.2.643.2.2.31.1 gost2012_256:XB:1.2.643.7.1.2.5.1.1 gost2012_256:XA: gost2012_512:A:1.2.643.2.2.31.3 gost2012_512:B:1.2.643.7.1.2.5.1.1 gost2012_512:A:}}
  73                 "open" {set enc_list {gost2001:XA:1.2.643.2.2.31.3 gost2001:XB:1.2.643.2.2.31.4 gost2001:XA: gost2012_256:XA:1.2.643.2.2.31.1 gost2012_256:XB:1.2.643.7.1.2.5.1.1 gost2012_256:XA: gost2012_512:A:1.2.643.2.2.31.3 gost2012_512:B:1.2.643.7.1.2.5.1.1 gost2012_512:A:}}
  74         }
  75 }
  76
  77 foreach enc_tuple $enc_list {
  78         if {![regexp {^([^:]*:[^:]*):(.*)$} $enc_tuple -> alg crypt_param]} {
  79                 set alg $enc_tuple
  80                 set crypt_param {}
  81         }
  82         set alg_fn [make_fn $enc_tuple]
  83         set username U_enc_$alg_fn
  84         switch -glob $alg {
  85                 gost2012* {set ::test::ca ${testname}CA-2012}
  86                 * {set ::test::ca ${testname}CA}
  87         }
  88
  89 test "Creating user $username with key $alg" {
  90         makeRegisteredUser $username $alg
  91
  92         if {![file exists $username/req.pem]&&[file exists $username/cert.pem]} {
  93                 file delete $username/cert.pem
  94         }
  95         file exists $username/cert.pem
  96 } 0 1
  97
  98 if {[string length $crypt_param]} {
  99         set env(CRYPT_PARAMS) $crypt_param
 100 } else {
 101         if {[info exists env(CRYPT_PARAMS)]} {unset env(CRYPT_PARAMS)}
 102 }
 103
 104 test -createsfiles enc_$alg_fn.msg "Encrypting for $username" {
 105         grep "rror" [openssl "smime -encrypt -in encrypt.dat -gost89 -out enc_$alg_fn.msg U_enc_$alg_fn/cert.pem"]
 106 } 0 ""
 107
 108 if {[info exists env(CRYPT_PARAMS)]} {unset env(CRYPT_PARAMS)}
 109
 110 test -createsfiles enc_$alg_fn.pem "Extracting PKCS7 from encrypted structure for $username" {
 111         openssl "smime -pk7out -out enc_$alg_fn.pem -in enc_$alg_fn.msg"
 112         file isfile enc_$alg_fn.pem
 113 } 0 1
 114
 115 test -skip {![file exists enc_$alg_fn.pem]} "Checking oids in pkcs7 structure for $username" {
 116         extract_oids enc_$alg_fn.pem PEM
 117 } 0 [mkObjList [alg_long_name $alg] [pubkey_long_name $alg] [param_hash_long_name [param_hash $alg]]  "GOST 28147-89" [encr_long_name $crypt_param]]
 118
 119 test -createsfiles decrypt.$alg_fn "Decrypting file encrypted for $username" {
 120         set expected [getFile encrypt.dat]
 121         openssl "smime -decrypt -in enc_$alg_fn.msg -recip U_enc_$alg_fn/cert.pem -inkey U_enc_$alg_fn/seckey.pem -out decrypt.$alg_fn"
 122         set result [getFile decrypt.$alg_fn]
 123         string eq $expected $result
 124 } 0 1
 125
 126 if {[string length $crypt_param]} {
 127         set env(CRYPT_PARAMS) $crypt_param
 128 } else {
 129         if {[info exists env(CRYPT_PARAMS)]} {unset env(CRYPT_PARAMS)}
 130 }
 131
 132 test -createsfiles enc_t_$alg_fn.msg "Encrypting for $username - text format" {
 133         grep "rror" [openssl "smime -encrypt -text -in encrypt.dat -gost89 -out enc_t_$alg_fn.msg U_enc_$alg_fn/cert.pem"]
 134 } 0 ""
 135
 136 if {[info exists env(CRYPT_PARAMS)]} {unset env(CRYPT_PARAMS)}
 137
 138 test -createsfiles decrypt_t.$alg_fn "Decrypting file text-encrypted for $username" {
 139         set expected [getFile encrypt.dat]
 140         openssl "smime -decrypt -text -in enc_t_$alg_fn.msg -recip U_enc_$alg_fn/cert.pem -inkey U_enc_$alg_fn/seckey.pem -out decrypt_t.$alg_fn"
 141         set result [getFile decrypt_t.$alg_fn]
 142         string eq $expected $result
 143 } 0 1
 144
 145 test -createsfiles decrypt_t_nocert.$alg_fn "Decrypting file text-encrypted for $username without cert" {
 146         set expected [getFile encrypt.dat]
 147         openssl "smime -decrypt -text -in enc_t_$alg_fn.msg -inkey U_enc_$alg_fn/seckey.pem -out decrypt_t_nocert.$alg_fn"
 148         set result [getFile decrypt_t_nocert.$alg_fn]
 149         string eq $expected $result
 150 } 0 1
 151 }
 152
 153 if {[info exists env(CRYPT_PARAMS)]} {unset env(CRYPT_PARAMS)}
 154
 155 # FIXME этот тест и парное расшифрование надо прогнать с разными параметрами шифрования
 156 test -createfiles enc_4all "Encrypt for all" {
 157         grep "rror" [openssl "smime -encrypt -in encrypt.dat -gost89 -out enc_4all.msg [map {U_enc_[make_fn $a]/cert.pem} $enc_list]"]
 158 } 0 ""
 159
 160 foreach enc_tuple $enc_list {
 161         if {![regexp {^([^:]*:[^:]*):(.*)$} $enc_tuple -> alg crypt_param]} {
 162                 set alg $enc_tuple
 163                 set crypt_param {}
 164         }
 165         set alg_fn [make_fn $enc_tuple]
 166         set username U_enc_$alg_fn
 167
 168 test -skip {![file exists enc_4all.msg]} -createsfiles decrypt_4all.$alg_fn "Decrypting gost-encrypted file, recipient $alg_fn" {
 169         set expected [getFile encrypt.dat]
 170         openssl "smime -decrypt -in enc_4all.msg -recip $username/cert.pem -inkey $username/seckey.pem -out decrypt_4all.$alg_fn"
 171         set result [getFile decrypt_4all.$alg_fn]
 172         string eq $expected $result
 173 } 0 1
 174
 175 test -skip {![file exists enc_4all.msg]} -createsfiles decrypt_4all_nocert.$alg_fn "Decrypting gost-encrypted file without cert, recipient $alg_fn" {
 176         set expected [getFile encrypt.dat]
 177         openssl "smime -decrypt -in enc_4all.msg -inkey $username/seckey.pem -out decrypt_4all_nocert.$alg_fn"
 178         set result [getFile decrypt_4all_nocert.$alg_fn]
 179         string eq $expected $result
 180 } 0 1
 181 }
 182
 183 restore_env2 {OPENSSL_CONF CRYPT_PARAMS}
 184
 185 end_tests