package.xml 0000644 0000765 0000024 00000023243 12171502055 010113 0 ustar
gnupg
pecl.php.net
wrapper around the gpgme library
This extension provides methods to interact with gnupg.
Jim Jagielski
jimjag
jimjag@php.net
yes
2013-07-17
1.3.3
1.3.3
stable
stable
BSD, revised
Fix compatibility with PHP 5.4 and 5.5
4.4
1.4.0b1
gnupg
1.3.3
1.3.3
stable
stable
2013-07-17
BSD, revised
Fix compatibility with PHP 5.4 and 5.5
1.3.2
1.3.2
stable
stable
2010-07-20
BSD, revised
Fix compatibility with gpgme >= 1.2.0 and crashes on 64-bit systems
1.3.1
1.3.1
stable
stable
2007-05-04
BSD, revised
fixed double-free with recent gpgme-lib
1.3
1.3
stable
stable
2006-11-06
BSD, revised
PHP 5.2 compatibility
gnupg_deletekey now allows deleting a secret key in procedural usage
bumped min version to 4.4
1.2
1.2
stable
stable
2006-05-23
BSD, revised
fixed bug #7587 (gnupg_verify fails with detached signature)
added "summary" into signature-array
1.1
1.1
stable
stable
2006-03-16
BSD, revised
improved PHP4 compatibility
passphrase-errors now takes care of the errormode
1.0
1.0
stable
stable
2005-12-29
BSD, revised
bump to stable
0.7.1
0.7.1
beta
beta
2005-12-01
BSD, revised
fixed PHP 5.1 build
0.7
0.7
beta
beta
2005-11-29
BSD, revised
changed licence to BSD, revised
fixed error during keyimport when the keyring is not writeable
fixed error when an invalid errormode is passed to seterrormode
0.6.1
0.6.1
beta
beta
2005-11-12
BSD, revised
fixed zts build
0.6
0.6
beta
beta
2005-11-12
BSD, revised
+ added seterrormode
- various memory optimizations
0.5
0.5
beta
beta
2005-10-25
BSD, revised
now supports multiple keys. added getsignatures. verify can now handle all signature types. therefore the API has changed.
0.4
0.4
beta
beta
2005-10-17
BSD, revised
added procedual usage and lowered min PHP Version to 4.3
0.3
0.3
beta
beta
2005-10-15
BSD, revised
added import/export methods and better errormessages
0.2
0.2
beta
beta
2005-10-10
BSD, revised
added keylistiterator, encryptsign and decryptverify
0.1
0.1
beta
beta
2005-10-07
BSD, revised
initial release
gnupg-1.3.3/tests/gnupg_oo_0001_import.phpt 0000644 0000765 0000024 00000001276 12171502055 015466 0 ustar --TEST--n
import a new key into the keyring
--SKIPIF--
--FILE--
seterrormode(gnupg::ERROR_WARNING);
$ret = $gpg -> import($testkey);
var_dump($ret);
?>
--EXPECT--
array(9) {
["imported"]=>
int(1)
["unchanged"]=>
int(0)
["newuserids"]=>
int(0)
["newsubkeys"]=>
int(0)
["secretimported"]=>
int(1)
["secretunchanged"]=>
int(0)
["newsignatures"]=>
int(0)
["skippedkeys"]=>
int(0)
["fingerprint"]=>
string(40) "64DF06E42FCF2094590CDEEE2E96F141B3DD2B2E"
}
gnupg-1.3.3/tests/gnupg_oo_encrypt.phpt 0000644 0000765 0000024 00000000715 12171502055 015175 0 ustar --TEST--
encrypt and decrypt a text
--SKIPIF--
--FILE--
seterrormode(gnupg::ERROR_WARNING);
$gpg -> addencryptkey($fingerprint);
$enc = $gpg -> encrypt($plaintext);
$gpg = NULL;
$gpg = new gnupg();
$gpg -> adddecryptkey($fingerprint, $passphrase);
$ret = $gpg -> decrypt ($enc);
var_dump($ret);
?>
--EXPECTF--
string(7) "foo bar"
gnupg-1.3.3/tests/gnupg_oo_encryptsign.phpt 0000644 0000765 0000024 00000001463 12171502055 016057 0 ustar --TEST--
encryptsign and decryptverify a text
--SKIPIF--
--FILE--
seterrormode(gnupg::ERROR_WARNING);
$gpg -> addencryptkey($fingerprint);
$gpg -> addsignkey($fingerprint, $passphrase);
$enc = $gpg -> encryptsign($plaintext);
$gpg = NULL;
$plaintext = false;
$gpg = new gnupg();
$gpg -> adddecryptkey($fingerprint, $passphrase);
$ret = $gpg -> decryptverify ($enc, $plaintext);
var_dump($ret);
var_dump($plaintext);
?>
--EXPECTF--
array(1) {
[0]=>
array(5) {
["fingerprint"]=>
string(40) "64DF06E42FCF2094590CDEEE2E96F141B3DD2B2E"
["validity"]=>
int(0)
["timestamp"]=>
int(%d)
["status"]=>
int(0)
["summary"]=>
int(0)
}
}
string(7) "foo bar"
gnupg-1.3.3/tests/gnupg_oo_export.phpt 0000644 0000765 0000024 00000003132 12171502055 015026 0 ustar --TEST--
export a key
--SKIPIF--
--FILE--
seterrormode(gnupg::ERROR_WARNING);
$ret = $gpg -> export($fingerprint);
var_dump($ret);
?>
--EXPECTF--
string(%d) "-----BEGIN PGP PUBLIC KEY BLOCK-----
Version: GnuPG v1.%d.%d (GNU/Linux)
mQGiBENQAKwRBADpy828KU+0SuoetJTrJ5dR86PiO3CsH8K6QRP7wY82Eh/9NTJ3
afRj0FNPaVSP0NciPeM4G4uFoQ3lsIf+FBEPXH1D97/XigWObU8K6ha2/s8wU98z
/samjTHLR+VKZ031B5/8p5Y49yvkkEyBkF1G85yeIXK0WZorKBPncRKuUwCgxOi/
IEa+ZuqHlmlDF2LTRIBOfrkEAK+WLRMWUD0bqj1TYwnxwPWiuns32/ZXLWuPfb5o
crNt7x5LSe7wJhjyIiFhiU0qR33X/FrT2umzOxlRYfINXT9DUHDocxxbED6fxAHw
X2IDd5tWXgCkSBHn2yAneNY6ycPdS3RvqJGlYFg7cOc0kz4urjqRt9fIagzpZQtL
fXHfBACl3EWgvLhVBo5ExZbrtlOA2q0x9UGhhNaSkeBWBr2qDeZErQjMTO0+viaN
/SX0zxeWtM3z06rkUHd1DKORDRM5R7shBTv9/Quojn0gbYbOem+e1mlCe27TRxcP
yeIKk00PqbVuff9QlK9GqKEWGzsEXCmxZ160Dul3CGlf/vQZHbQkdGVzdGtleSAo
dGVzdGtleSkgPHRlc3RAZXhhbXBsZS5uZXQ+iF4EExECAB4FAkNQAKwCGwMGCwkI
BwMCAxUCAwMWAgECHgECF4AACgkQLpbxQbPdKy58pwCcDz9qEBEVt1gcKCwNay0f
m4vLqCkAn1P0KV1giECUVXBuZ5YUndDB1QqtuQENBENQAK0QBACNXzJQG4NHUJqL
PImezbl+ii+93MjMo8LpSlv9Np5ruWIKtxuqmVEe4k+r1DDmSl8hppifpRtx2hef
bDTl8Tdf5MNGvf5JE3AHYUehZ+ldjgYCOZ53fJDgKV65ZidQSGGXsRcyE7SHgMQ6
rTL92PA2IQmkcf9xkg6xM2h55UusMwADBQP9EGQ0BAdWRUtA21/cR6F+t97KZnVS
et225UYv8azv8p8cK4R1lrZXChFadK9Kt+/My4HAx7J7zd1IPuKQ0QniuvuLT3Mw
z19B7FGXaJenwTw0P1ihtmSPq9GAOkOA4ZPhHLl9OFwIeAZzjfshRfvm0haO3vwl
xdjhwxyJ/a/JEF2ISQQYEQIACQUCQ1AArQIbDAAKCRAulvFBs90rLrBkAJ9tScp6
drhhPQJw1AY6GEpSbK0JtACeJuewK8C1wO1l5OYkGzFpb4VgquI=
=twR+
-----END PGP PUBLIC KEY BLOCK-----
"
gnupg-1.3.3/tests/gnupg_oo_keyinfo.phpt 0000644 0000765 0000024 00000004051 12171502055 015152 0 ustar --TEST--n
get keyinfo
--SKIPIF--
--FILE--
seterrormode(gnupg::ERROR_WARNING);
$ret = $gpg -> keyinfo($fingerprint);
var_dump($ret);
?>
--EXPECT--
array(1) {
[0]=>
array(8) {
["disabled"]=>
bool(false)
["expired"]=>
bool(false)
["revoked"]=>
bool(false)
["is_secret"]=>
bool(false)
["can_sign"]=>
bool(true)
["can_encrypt"]=>
bool(true)
["uids"]=>
array(1) {
[0]=>
array(6) {
["name"]=>
string(7) "testkey"
["comment"]=>
string(7) "testkey"
["email"]=>
string(16) "test@example.net"
["uid"]=>
string(36) "testkey (testkey) "
["revoked"]=>
bool(false)
["invalid"]=>
bool(false)
}
}
["subkeys"]=>
array(2) {
[0]=>
array(11) {
["fingerprint"]=>
string(40) "64DF06E42FCF2094590CDEEE2E96F141B3DD2B2E"
["keyid"]=>
string(16) "2E96F141B3DD2B2E"
["timestamp"]=>
int(1129316524)
["expires"]=>
int(0)
["is_secret"]=>
bool(false)
["invalid"]=>
bool(false)
["can_encrypt"]=>
bool(false)
["can_sign"]=>
bool(true)
["disabled"]=>
bool(false)
["expired"]=>
bool(false)
["revoked"]=>
bool(false)
}
[1]=>
array(11) {
["fingerprint"]=>
string(40) "A3437D3651E27CF9864198F0BFE8D07DDACDEAC8"
["keyid"]=>
string(16) "BFE8D07DDACDEAC8"
["timestamp"]=>
int(1129316525)
["expires"]=>
int(0)
["is_secret"]=>
bool(false)
["invalid"]=>
bool(false)
["can_encrypt"]=>
bool(true)
["can_sign"]=>
bool(false)
["disabled"]=>
bool(false)
["expired"]=>
bool(false)
["revoked"]=>
bool(false)
}
}
}
}
gnupg-1.3.3/tests/gnupg_oo_listsignatures.phpt 0000644 0000765 0000024 00000001402 12171502055 016563 0 ustar --TEST--n
list signatures
--SKIPIF--
--FILE--
seterrormode(gnupg::ERROR_WARNING);
$ret = $gpg -> listsignatures($fingerprint);
var_dump($ret);
?>
--EXPECT--
array(1) {
["testkey (testkey) "]=>
array(1) {
["2E96F141B3DD2B2E"]=>
array(8) {
["uid"]=>
string(36) "testkey (testkey) "
["name"]=>
string(7) "testkey"
["email"]=>
string(16) "test@example.net"
["comment"]=>
string(7) "testkey"
["expires"]=>
int(0)
["revoked"]=>
bool(false)
["expired"]=>
bool(false)
["invalid"]=>
bool(false)
}
}
}
gnupg-1.3.3/tests/gnupg_oo_sign_clear.phpt 0000644 0000765 0000024 00000001363 12171502055 015617 0 ustar --TEST--n
sign a text with sigmode SIG_MODE_CLEAR
--SKIPIF--
--FILE--
seterrormode(gnupg::ERROR_WARNING);
$gpg -> setsignmode(gnupg::SIG_MODE_CLEAR);
$gpg -> addsignkey($fingerprint, $passphrase);
$ret = $gpg -> sign($plaintext);
$gpg = NULL;
$gpg = new gnupg();
$tmp = false;
$ret = $gpg -> verify($ret, false, $tmp);
var_dump($ret);
var_dump($tmp);
?>
--EXPECTF--
array(1) {
[0]=>
array(5) {
["fingerprint"]=>
string(40) "64DF06E42FCF2094590CDEEE2E96F141B3DD2B2E"
["validity"]=>
int(0)
["timestamp"]=>
int(%d)
["status"]=>
int(0)
["summary"]=>
int(0)
}
}
string(8) "foo bar
"
gnupg-1.3.3/tests/gnupg_oo_sign_detach.phpt 0000644 0000765 0000024 00000001366 12171502055 015764 0 ustar --TEST--n
sign a text with mode SIG_MODE_DETACH
--SKIPIF--
--FILE--
seterrormode(gnupg::ERROR_WARNING);
$gpg -> setsignmode(gnupg::SIG_MODE_DETACH);
$gpg -> addsignkey($fingerprint, $passphrase);
$ret = $gpg -> sign($plaintext);
$gpg = NULL;
$gpg = new gnupg();
$tmp = false;
$ret = $gpg -> verify($plaintext, $ret);
var_dump($ret);
var_dump($plaintext);
?>
--EXPECTF--
array(1) {
[0]=>
array(5) {
["fingerprint"]=>
string(40) "64DF06E42FCF2094590CDEEE2E96F141B3DD2B2E"
["validity"]=>
int(0)
["timestamp"]=>
int(%d)
["status"]=>
int(0)
["summary"]=>
int(0)
}
}
string(7) "foo bar"
gnupg-1.3.3/tests/gnupg_oo_sign_detach_nonarmor.phpt 0000644 0000765 0000024 00000001446 12171502055 017676 0 ustar --TEST--n
sign a text with mode SIG_MODE_DETACH and without armored output
--SKIPIF--
--FILE--
seterrormode(gnupg::ERROR_WARNING);
$gpg -> setarmor(0);
$gpg -> setsignmode(gnupg::SIG_MODE_DETACH);
$gpg -> addsignkey($fingerprint, $passphrase);
$ret = $gpg -> sign($plaintext);
$gpg = NULL;
$gpg = new gnupg();
$tmp = false;
$ret = $gpg -> verify($plaintext, $ret);
var_dump($ret);
var_dump($plaintext);
?>
--EXPECTF--
array(1) {
[0]=>
array(5) {
["fingerprint"]=>
string(40) "64DF06E42FCF2094590CDEEE2E96F141B3DD2B2E"
["validity"]=>
int(0)
["timestamp"]=>
int(%d)
["status"]=>
int(0)
["summary"]=>
int(0)
}
}
string(7) "foo bar"
gnupg-1.3.3/tests/gnupg_oo_sign_normal.phpt 0000644 0000765 0000024 00000001421 12171502055 016014 0 ustar --TEST--n
sign a text with mode SIG_MODE_NORMAL
--SKIPIF--
--FILE--
seterrormode(gnupg::ERROR_WARNING);
$gpg -> setsignmode(gnupg::SIG_MODE_NORMAL);
$gpg -> addsignkey($fingerprint, $passphrase);
$ret = $gpg -> sign($plaintext);
$gpg = NULL;
$gpg = new gnupg();
$tmp = false;
$plaintext = false;
$ret = $gpg -> verify($ret, false, $plaintext);
var_dump($ret);
var_dump($plaintext);
?>
--EXPECTF--
array(1) {
[0]=>
array(5) {
["fingerprint"]=>
string(40) "64DF06E42FCF2094590CDEEE2E96F141B3DD2B2E"
["validity"]=>
int(0)
["timestamp"]=>
int(%d)
["status"]=>
int(0)
["summary"]=>
int(0)
}
}
string(7) "foo bar"
gnupg-1.3.3/tests/gnupg_oo_sign_normal_noarmor.phpt 0000644 0000765 0000024 00000001536 12171502055 017560 0 ustar --TEST--n
sign a text with mode SIG_MODE_NORMAL and without armored output
--SKIPIF--
--FILE--
seterrormode(gnupg::ERROR_WARNING);
$gpg -> setarmor(0);
$gpg -> setsignmode(gnupg::SIG_MODE_NORMAL);
$gpg -> addsignkey($fingerprint, $passphrase);
$ret = $gpg -> sign($plaintext);
$gpg = NULL;
$gpg = new gnupg();
//$ret = $gpg -> verify($plaintext, $ret);
$plaintext = false;
$ret = $gpg -> verify($ret, false, $plaintext);
var_dump($ret);
var_dump($plaintext);
?>
--EXPECTF--
array(1) {
[0]=>
array(5) {
["fingerprint"]=>
string(40) "64DF06E42FCF2094590CDEEE2E96F141B3DD2B2E"
["validity"]=>
int(0)
["timestamp"]=>
int(%d)
["status"]=>
int(0)
["summary"]=>
int(0)
}
}
string(7) "foo bar"
gnupg-1.3.3/tests/gnupg_oo_zzz_deletekey.phpt 0000644 0000765 0000024 00000000466 12171502055 016404 0 ustar --TEST--n
delete a key from the keyring
--SKIPIF--
--FILE--
seterrormode(gnupg::ERROR_WARNING);
$ret = $gpg -> deletekey($fingerprint,true);
var_dump($ret);
?>
--EXPECT--
bool(true)
gnupg-1.3.3/tests/gnupg_res_0001_import.phpt 0000644 0000765 0000024 00000001212 12171502055 015630 0 ustar --TEST--n
import a new key into the keyring
--FILE--
--EXPECT--
array(9) {
["imported"]=>
int(1)
["unchanged"]=>
int(0)
["newuserids"]=>
int(0)
["newsubkeys"]=>
int(0)
["secretimported"]=>
int(1)
["secretunchanged"]=>
int(0)
["newsignatures"]=>
int(0)
["skippedkeys"]=>
int(0)
["fingerprint"]=>
string(40) "64DF06E42FCF2094590CDEEE2E96F141B3DD2B2E"
}
gnupg-1.3.3/tests/gnupg_res_encrypt.phpt 0000644 0000765 0000024 00000000646 12171502055 015354 0 ustar --TEST--
encrypt and decrypt a text
--FILE--
--EXPECTF--
string(7) "foo bar"
gnupg-1.3.3/tests/gnupg_res_encryptsign.phpt 0000644 0000765 0000024 00000001420 12171502055 016224 0 ustar --TEST--
encryptsign and decryptverify a text
--FILE--
--EXPECTF--
array(1) {
[0]=>
array(5) {
["fingerprint"]=>
string(40) "64DF06E42FCF2094590CDEEE2E96F141B3DD2B2E"
["validity"]=>
int(0)
["timestamp"]=>
int(%d)
["status"]=>
int(0)
["summary"]=>
int(0)
}
}
string(7) "foo bar"
gnupg-1.3.3/tests/gnupg_res_export.phpt 0000644 0000765 0000024 00000003046 12171502055 015206 0 ustar --TEST--
export a key
--FILE--
--EXPECTF--
string(%d) "-----BEGIN PGP PUBLIC KEY BLOCK-----
Version: GnuPG v1.%d.%d (GNU/Linux)
mQGiBENQAKwRBADpy828KU+0SuoetJTrJ5dR86PiO3CsH8K6QRP7wY82Eh/9NTJ3
afRj0FNPaVSP0NciPeM4G4uFoQ3lsIf+FBEPXH1D97/XigWObU8K6ha2/s8wU98z
/samjTHLR+VKZ031B5/8p5Y49yvkkEyBkF1G85yeIXK0WZorKBPncRKuUwCgxOi/
IEa+ZuqHlmlDF2LTRIBOfrkEAK+WLRMWUD0bqj1TYwnxwPWiuns32/ZXLWuPfb5o
crNt7x5LSe7wJhjyIiFhiU0qR33X/FrT2umzOxlRYfINXT9DUHDocxxbED6fxAHw
X2IDd5tWXgCkSBHn2yAneNY6ycPdS3RvqJGlYFg7cOc0kz4urjqRt9fIagzpZQtL
fXHfBACl3EWgvLhVBo5ExZbrtlOA2q0x9UGhhNaSkeBWBr2qDeZErQjMTO0+viaN
/SX0zxeWtM3z06rkUHd1DKORDRM5R7shBTv9/Quojn0gbYbOem+e1mlCe27TRxcP
yeIKk00PqbVuff9QlK9GqKEWGzsEXCmxZ160Dul3CGlf/vQZHbQkdGVzdGtleSAo
dGVzdGtleSkgPHRlc3RAZXhhbXBsZS5uZXQ+iF4EExECAB4FAkNQAKwCGwMGCwkI
BwMCAxUCAwMWAgECHgECF4AACgkQLpbxQbPdKy58pwCcDz9qEBEVt1gcKCwNay0f
m4vLqCkAn1P0KV1giECUVXBuZ5YUndDB1QqtuQENBENQAK0QBACNXzJQG4NHUJqL
PImezbl+ii+93MjMo8LpSlv9Np5ruWIKtxuqmVEe4k+r1DDmSl8hppifpRtx2hef
bDTl8Tdf5MNGvf5JE3AHYUehZ+ldjgYCOZ53fJDgKV65ZidQSGGXsRcyE7SHgMQ6
rTL92PA2IQmkcf9xkg6xM2h55UusMwADBQP9EGQ0BAdWRUtA21/cR6F+t97KZnVS
et225UYv8azv8p8cK4R1lrZXChFadK9Kt+/My4HAx7J7zd1IPuKQ0QniuvuLT3Mw
z19B7FGXaJenwTw0P1ihtmSPq9GAOkOA4ZPhHLl9OFwIeAZzjfshRfvm0haO3vwl
xdjhwxyJ/a/JEF2ISQQYEQIACQUCQ1AArQIbDAAKCRAulvFBs90rLrBkAJ9tScp6
drhhPQJw1AY6GEpSbK0JtACeJuewK8C1wO1l5OYkGzFpb4VgquI=
=twR+
-----END PGP PUBLIC KEY BLOCK-----
"
gnupg-1.3.3/tests/gnupg_res_keyinfo.phpt 0000644 0000765 0000024 00000003765 12171502055 015341 0 ustar --TEST--n
get keyinfo
--FILE--
--EXPECT--
array(1) {
[0]=>
array(8) {
["disabled"]=>
bool(false)
["expired"]=>
bool(false)
["revoked"]=>
bool(false)
["is_secret"]=>
bool(false)
["can_sign"]=>
bool(true)
["can_encrypt"]=>
bool(true)
["uids"]=>
array(1) {
[0]=>
array(6) {
["name"]=>
string(7) "testkey"
["comment"]=>
string(7) "testkey"
["email"]=>
string(16) "test@example.net"
["uid"]=>
string(36) "testkey (testkey) "
["revoked"]=>
bool(false)
["invalid"]=>
bool(false)
}
}
["subkeys"]=>
array(2) {
[0]=>
array(11) {
["fingerprint"]=>
string(40) "64DF06E42FCF2094590CDEEE2E96F141B3DD2B2E"
["keyid"]=>
string(16) "2E96F141B3DD2B2E"
["timestamp"]=>
int(1129316524)
["expires"]=>
int(0)
["is_secret"]=>
bool(false)
["invalid"]=>
bool(false)
["can_encrypt"]=>
bool(false)
["can_sign"]=>
bool(true)
["disabled"]=>
bool(false)
["expired"]=>
bool(false)
["revoked"]=>
bool(false)
}
[1]=>
array(11) {
["fingerprint"]=>
string(40) "A3437D3651E27CF9864198F0BFE8D07DDACDEAC8"
["keyid"]=>
string(16) "BFE8D07DDACDEAC8"
["timestamp"]=>
int(1129316525)
["expires"]=>
int(0)
["is_secret"]=>
bool(false)
["invalid"]=>
bool(false)
["can_encrypt"]=>
bool(true)
["can_sign"]=>
bool(false)
["disabled"]=>
bool(false)
["expired"]=>
bool(false)
["revoked"]=>
bool(false)
}
}
}
}
gnupg-1.3.3/tests/gnupg_res_listsignatures.phpt 0000644 0000765 0000024 00000001316 12171502055 016743 0 ustar --TEST--n
list signatures
--FILE--
--EXPECT--
array(1) {
["testkey (testkey) "]=>
array(1) {
["2E96F141B3DD2B2E"]=>
array(8) {
["uid"]=>
string(36) "testkey (testkey) "
["name"]=>
string(7) "testkey"
["email"]=>
string(16) "test@example.net"
["comment"]=>
string(7) "testkey"
["expires"]=>
int(0)
["revoked"]=>
bool(false)
["expired"]=>
bool(false)
["invalid"]=>
bool(false)
}
}
}
gnupg-1.3.3/tests/gnupg_res_sign_clear.phpt 0000644 0000765 0000024 00000001313 12171502055 015766 0 ustar --TEST--n
sign a text with sigmode SIG_MODE_CLEAR
--FILE--
--EXPECTF--
array(1) {
[0]=>
array(5) {
["fingerprint"]=>
string(40) "64DF06E42FCF2094590CDEEE2E96F141B3DD2B2E"
["validity"]=>
int(0)
["timestamp"]=>
int(%d)
["status"]=>
int(0)
["summary"]=>
int(0)
}
}
string(8) "foo bar
"
gnupg-1.3.3/tests/gnupg_res_sign_detach.phpt 0000644 0000765 0000024 00000001315 12171502055 016132 0 ustar --TEST--n
sign a text with mode SIG_MODE_DETACH
--FILE--
--EXPECTF--
array(1) {
[0]=>
array(5) {
["fingerprint"]=>
string(40) "64DF06E42FCF2094590CDEEE2E96F141B3DD2B2E"
["validity"]=>
int(0)
["timestamp"]=>
int(%d)
["status"]=>
int(0)
["summary"]=>
int(0)
}
}
string(7) "foo bar"
gnupg-1.3.3/tests/gnupg_res_sign_detach_nonarmor.phpt 0000644 0000765 0000024 00000001402 12171502055 020042 0 ustar --TEST--n
sign a text with mode SIG_MODE_DETACH and without armored output
--FILE--
--EXPECTF--
array(1) {
[0]=>
array(5) {
["fingerprint"]=>
string(40) "64DF06E42FCF2094590CDEEE2E96F141B3DD2B2E"
["validity"]=>
int(0)
["timestamp"]=>
int(%d)
["status"]=>
int(0)
["summary"]=>
int(0)
}
}
string(7) "foo bar"
gnupg-1.3.3/tests/gnupg_res_sign_normal.phpt 0000644 0000765 0000024 00000001350 12171502055 016171 0 ustar --TEST--n
sign a text with mode SIG_MODE_NORMAL
--FILE--
--EXPECTF--
array(1) {
[0]=>
array(5) {
["fingerprint"]=>
string(40) "64DF06E42FCF2094590CDEEE2E96F141B3DD2B2E"
["validity"]=>
int(0)
["timestamp"]=>
int(%d)
["status"]=>
int(0)
["summary"]=>
int(0)
}
}
string(7) "foo bar"
gnupg-1.3.3/tests/gnupg_res_sign_normal_noarmor.phpt 0000644 0000765 0000024 00000001417 12171502055 017732 0 ustar --TEST--n
sign a text with mode SIG_MODE_NORMAL and without armored output
--FILE--
--EXPECTF--
array(1) {
[0]=>
array(5) {
["fingerprint"]=>
string(40) "64DF06E42FCF2094590CDEEE2E96F141B3DD2B2E"
["validity"]=>
int(0)
["timestamp"]=>
int(%d)
["status"]=>
int(0)
["summary"]=>
int(0)
}
}
string(7) "foo bar"
gnupg-1.3.3/tests/gnupg_res_zzz_deletekey.phpt 0000644 0000765 0000024 00000000402 12171502055 016546 0 ustar --TEST--n
delete a key from the keyring
--FILE--
--EXPECT--
bool(true)
gnupg-1.3.3/tests/vars.inc 0000644 0000765 0000024 00000003303 12171502055 012361 0 ustar
gnupg-1.3.3/config.m4 0000644 0000765 0000024 00000003423 12171502055 011263 0 ustar dnl $Id: config.m4 330741 2013-07-02 15:33:55Z jimjag $
dnl config.m4 for extension gnupg
PHP_ARG_WITH(gnupg, for gnupg support,
[ --with-gnupg[=dir] Include gnupg support])
if test "$PHP_GNUPG" != "no"; then
SEARCH_PATH="/usr/local/include /usr/include /usr/local/include/gpgme/ /usr/include/gpgme/"
SEARCH_FOR="gpgme.h"
if test -r $PHP_GNUPG/$SEARCH_FOR; then
GNUPG_DIR=$PHP_GNUPG
else
AC_MSG_CHECKING([for gnupg files in default path])
for i in $SEARCH_PATH ; do
if test -r $i/$SEARCH_FOR; then
GNUPG_DIR=$i
AC_MSG_RESULT(found in $i)
fi
done
fi
if test -z "$GNUPG_DIR"; then
AC_MSG_RESULT([not found])
AC_MSG_ERROR([Please reinstall the gpgme distribution])
fi
PHP_ADD_INCLUDE($GNUPG_DIR)
LIBNAME=gpgme
LIBSYMBOL=gpgme_check_version
PHP_CHECK_LIBRARY($LIBNAME,$LIBSYMBOL,
[
PHP_ADD_LIBRARY_WITH_PATH($LIBNAME, $GNUPG_DIR/lib, GNUPG_SHARED_LIBADD)
AC_DEFINE(HAVE_GNUPGLIB,1,[ ])
],[
AC_MSG_ERROR([wrong gpgme lib version or lib not found])
],[
-L$GNUPG_DIR/lib -lm -ldl
])
PHP_SUBST(GNUPG_SHARED_LIBADD)
PHP_NEW_EXTENSION(gnupg, [gnupg.c gnupg_keylistiterator.c], $ext_shared)
fi
AC_ARG_WITH([gpg], [AS_HELP_STRING([--with-gpg],
[path to gpg v1.x])], [], [with_gpg=no])
AC_PATH_PROG(GNUPG_PATH, gpg)
if test "$with_gpg" != "no"; then
if test "$with_gpg" != "yes"; then
if test -x "$with_gpg"; then
ac_cv_path_GNUPG_PATH=$with_gpg
else
if test -x "$ac_cv_path_GNUPG_PATH"; then
AC_MSG_RESULT($with_gpg invalid: using $ac_cv_path_GNUPG_PATH)
else
AC_MSG_RESULT($with_gpg invalid)
fi
fi
fi
if test -x "$ac_cv_path_GNUPG_PATH"; then
AC_DEFINE_UNQUOTED([GNUPG_PATH], ["$ac_cv_path_GNUPG_PATH"], [Path to gpg v1.x])
fi
fi
gnupg-1.3.3/EXPERIMENTAL 0000644 0000765 0000024 00000000000 12171502055 011360 0 ustar gnupg-1.3.3/gnupg.c 0000644 0000765 0000024 00000142230 12171502055 011040 0 ustar /*
+--------------------------------------------------------------------+
| PECL :: gnupg |
+--------------------------------------------------------------------+
| Redistribution and use in source and binary forms, with or without |
| modification, are permitted provided that the conditions mentioned |
| in the accompanying LICENSE file are met. |
+--------------------------------------------------------------------+
| Copyright (c) 2006, Thilo Raufeisen |
| Copyright (c) 2013, Jim Jagielski |
+--------------------------------------------------------------------+
*/
/* $Id: gnupg.c 330830 2013-07-09 13:09:18Z remi $ */
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include "php.h"
#include "php_ini.h"
#include "zend_exceptions.h"
#include "ext/standard/info.h"
#include "php_gnupg.h"
#ifdef ZEND_ENGINE_2
#include "php_gnupg_keylistiterator.h"
#endif
static int le_gnupg;
#ifdef ZEND_ENGINE_2
static zend_object_handlers gnupg_object_handlers;
#endif
/* {{{ defs */
#ifdef ZEND_ENGINE_2
#define GNUPG_GETOBJ() \
zval *this = getThis(); \
gnupg_object *intern; \
zval *res; \
if(this){ \
intern = (gnupg_object*) zend_object_store_get_object(getThis() TSRMLS_CC); \
if(!intern){ \
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid or unitialized gnupg object"); \
RETURN_FALSE; \
} \
}
#define GNUPG_ERR(error) \
if(intern){ \
switch (intern->errormode) { \
case 1: \
php_error_docref(NULL TSRMLS_CC, E_WARNING, (char*)error); \
break; \
case 2: \
zend_throw_exception(zend_exception_get_default(TSRMLS_C), (char*) error, 0 TSRMLS_CC); \
break; \
default: \
intern->errortxt = (char*)error; \
} \
}else{ \
php_error_docref(NULL TSRMLS_CC, E_WARNING, (char*)error); \
} \
if(return_value){ \
RETVAL_FALSE; \
}
#else
#define GNUPG_ERR(error) \
if(intern && intern->errormode!=1) { \
intern->errortxt = (char*)error; \
}else{ \
php_error_docref(NULL TSRMLS_CC, E_WARNING, (char*)error); \
} \
if(return_value){ \
RETVAL_FALSE; \
}
#define GNUPG_GETOBJ() \
zval *this = NULL; \
zval *res; \
gnupg_object *intern;
#endif
/* }}} */
/* {{{ free encryptkeys */
static void gnupg_free_encryptkeys(gnupg_object *intern TSRMLS_DC){
if(intern){
int idx;
/* loop through all encryptkeys and unref them in the gpgme-lib */
for(idx=0;idxencrypt_size;idx++){
gpgme_key_unref (intern->encryptkeys[idx]);
}
/* it´s an odd-thing, but other solutions makes problems :
* erealloc(x,0) gives a segfault with PHP 4 and debug enabled
* efree(x) alone ends in a segfault
*/
efree(erealloc(intern->encryptkeys,0));
intern->encryptkeys = NULL;
intern->encrypt_size = 0;
}
}
/* }}} */
/* {{{ free_resource */
static void gnupg_free_resource_ptr(gnupg_object *intern TSRMLS_DC){
if(intern){
if(intern->ctx){
/* clear all signers from the gpgme-lib and finally release it */
gpgme_signers_clear (intern->ctx);
gpgme_release (intern->ctx);
intern->ctx = NULL;
}
/* basic cleanup */
gnupg_free_encryptkeys(intern TSRMLS_CC);
zend_hash_destroy(intern->signkeys);
FREE_HASHTABLE(intern->signkeys);
zend_hash_destroy(intern->decryptkeys);
FREE_HASHTABLE(intern->decryptkeys);
}
}
/* }}} */
/* {{{ gnupg_res_dtor */
static void gnupg_res_dtor(zend_rsrc_list_entry *rsrc TSRMLS_DC) {
gnupg_object *intern;
intern = (gnupg_object *) rsrc->ptr;
gnupg_free_resource_ptr(intern TSRMLS_CC);
efree(intern);
}
/* }}} */
/* {{{ gnupg_res_init */
static void gnupg_res_init(gnupg_object *intern TSRMLS_DC){
/* init the gpgme-lib and set the default values */
gpgme_ctx_t ctx;
gpgme_check_version (NULL);
gpgme_new (&ctx);
#ifdef GNUPG_PATH
gpgme_ctx_set_engine_info(ctx, GPGME_PROTOCOL_OpenPGP, GNUPG_PATH, NULL);
#endif
gpgme_set_armor (ctx,1);
intern->ctx = ctx;
intern->encryptkeys = NULL;
intern->encrypt_size = 0;
intern->signmode = GPGME_SIG_MODE_CLEAR;
intern->errortxt = NULL;
intern->errormode = 3;
ALLOC_HASHTABLE (intern->signkeys);
zend_hash_init (intern->signkeys, 0, NULL, NULL, 0);
ALLOC_HASHTABLE (intern->decryptkeys);
zend_hash_init (intern->decryptkeys, 0, NULL, NULL, 0);
return;
}
/* }}} */
#ifdef ZEND_ENGINE_2
/* {{{ free_storage */
static void gnupg_obj_dtor(gnupg_object *intern TSRMLS_DC){
if(!intern){
return;
}
gnupg_free_resource_ptr(intern TSRMLS_CC);
if(intern->zo.properties){
zend_hash_destroy(intern->zo.properties);
FREE_HASHTABLE(intern->zo.properties);
}
efree(intern);
}
/* }}} */
/* {{{ objects_new */
zend_object_value gnupg_obj_new(zend_class_entry *class_type TSRMLS_DC){
gnupg_object *intern;
#if PHP_VERSION_ID < 50399
zval *tmp;
#endif
zend_object_value retval;
intern = ecalloc(1, sizeof(gnupg_object));
intern->zo.ce = class_type;
#if PHP_VERSION_ID < 50399
intern->zo.properties = NULL;
ALLOC_HASHTABLE (intern->zo.properties);
zend_hash_init (intern->zo.properties, 0, NULL, ZVAL_PTR_DTOR, 0);
zend_hash_copy (intern->zo.properties, &class_type->default_properties, (copy_ctor_func_t) zval_add_ref, (void *) &tmp, sizeof(zval *));
#else
object_properties_init(&intern->zo, class_type);
#endif
retval.handle = zend_objects_store_put(intern,NULL,(zend_objects_free_object_storage_t) gnupg_obj_dtor,NULL TSRMLS_CC);
retval.handlers = (zend_object_handlers *) & gnupg_object_handlers;
gnupg_res_init (intern TSRMLS_CC);
return retval;
}
/* }}} */
/* {{{ methodlist gnupg */
static zend_function_entry gnupg_methods[] = {
PHP_FALIAS(keyinfo, gnupg_keyinfo, NULL)
PHP_FALIAS(verify, gnupg_verify, NULL)
PHP_FALIAS(geterror, gnupg_geterror, NULL)
PHP_FALIAS(clearsignkeys, gnupg_clearsignkeys, NULL)
PHP_FALIAS(clearencryptkeys, gnupg_clearencryptkeys, NULL)
PHP_FALIAS(cleardecryptkeys, gnupg_cleardecryptkeys, NULL)
PHP_FALIAS(setarmor, gnupg_setarmor, NULL)
PHP_FALIAS(encrypt, gnupg_encrypt, NULL)
PHP_FALIAS(decrypt, gnupg_decrypt, NULL)
PHP_FALIAS(export, gnupg_export, NULL)
PHP_FALIAS(import, gnupg_import, NULL)
PHP_FALIAS(getprotocol, gnupg_getprotocol, NULL)
PHP_FALIAS(setsignmode, gnupg_setsignmode, NULL)
PHP_FALIAS(sign, gnupg_sign, NULL)
PHP_FALIAS(encryptsign, gnupg_encryptsign, NULL)
PHP_FALIAS(decryptverify, gnupg_decryptverify, NULL)
PHP_FALIAS(addsignkey, gnupg_addsignkey, NULL)
PHP_FALIAS(addencryptkey, gnupg_addencryptkey, NULL)
PHP_FALIAS(adddecryptkey, gnupg_adddecryptkey, NULL)
PHP_FALIAS(deletekey, gnupg_deletekey, NULL)
PHP_FALIAS(gettrustlist, gnupg_gettrustlist, NULL)
PHP_FALIAS(listsignatures, gnupg_listsignatures, NULL)
PHP_FALIAS(seterrormode, gnupg_seterrormode, NULL)
{NULL, NULL, NULL}
};
/* }}} */
/* {{{ class constants */
static void gnupg_declare_long_constant(const char *const_name, long value TSRMLS_DC){
#if PHP_MAJOR_VERSION > 5 || PHP_MINOR_VERSION >= 1
zend_declare_class_constant_long(gnupg_class_entry, (char*)const_name, strlen(const_name), value TSRMLS_CC);
#else
zval *constant = malloc(sizeof(*constant));
ZVAL_LONG(constant,value);
INIT_PZVAL(constant);
zend_hash_update(&gnupg_class_entry->constants_table, (char*)const_name, strlen(const_name)+1, &constant, sizeof(zval*), NULL);
#endif
}
/* }}} */
#endif /* ZEND_ENGINE_2 */
/* {{{ functionlist gnupg */
static zend_function_entry gnupg_functions[] = {
PHP_FE(gnupg_init, NULL)
PHP_FE(gnupg_keyinfo, NULL)
PHP_FE(gnupg_sign, NULL)
PHP_FE(gnupg_verify, NULL)
PHP_FE(gnupg_clearsignkeys, NULL)
PHP_FE(gnupg_clearencryptkeys, NULL)
PHP_FE(gnupg_cleardecryptkeys, NULL)
PHP_FE(gnupg_setarmor, NULL)
PHP_FE(gnupg_encrypt, NULL)
PHP_FE(gnupg_decrypt, NULL)
PHP_FE(gnupg_export, NULL)
PHP_FE(gnupg_import, NULL)
PHP_FE(gnupg_getprotocol, NULL)
PHP_FE(gnupg_setsignmode, NULL)
PHP_FE(gnupg_encryptsign, NULL)
PHP_FE(gnupg_decryptverify, NULL)
PHP_FE(gnupg_geterror, NULL)
PHP_FE(gnupg_addsignkey, NULL)
PHP_FE(gnupg_addencryptkey, NULL)
PHP_FE(gnupg_adddecryptkey, NULL)
PHP_FE(gnupg_deletekey, NULL)
PHP_FE(gnupg_gettrustlist, NULL)
PHP_FE(gnupg_listsignatures, NULL)
PHP_FE(gnupg_seterrormode, NULL)
{NULL, NULL, NULL}
};
/* }}} */
/* {{{ gnupg_module_entry
*/
zend_module_entry gnupg_module_entry = {
#if ZEND_MODULE_API_NO >= 20010901
STANDARD_MODULE_HEADER,
#endif
"gnupg",
gnupg_functions,
PHP_MINIT(gnupg),
PHP_MSHUTDOWN(gnupg),
NULL,
NULL,
PHP_MINFO(gnupg),
#if ZEND_MODULE_API_NO >= 20010901
PHP_GNUPG_VERSION,
#endif
STANDARD_MODULE_PROPERTIES
};
/* }}} */
#ifdef COMPILE_DL_GNUPG
ZEND_GET_MODULE(gnupg)
#endif
/* {{{ PHP_MINIT_FUNCTION
*/
PHP_MINIT_FUNCTION(gnupg)
{
le_gnupg = zend_register_list_destructors_ex(gnupg_res_dtor, NULL, "ctx", module_number);
#ifdef ZEND_ENGINE_2
zend_class_entry ce;
INIT_CLASS_ENTRY(ce, "gnupg", gnupg_methods);
ce.create_object = gnupg_obj_new;
gnupg_class_entry = zend_register_internal_class(&ce TSRMLS_CC);
memcpy(&gnupg_object_handlers, zend_get_std_object_handlers(), sizeof(zend_object_handlers));
if (SUCCESS != gnupg_keylistiterator_init()){
return FAILURE;
}
gnupg_declare_long_constant("SIG_MODE_NORMAL", GPGME_SIG_MODE_NORMAL TSRMLS_CC);
gnupg_declare_long_constant("SIG_MODE_DETACH", GPGME_SIG_MODE_DETACH TSRMLS_CC);
gnupg_declare_long_constant("SIG_MODE_CLEAR", GPGME_SIG_MODE_CLEAR TSRMLS_CC);
gnupg_declare_long_constant("VALIDITY_UNKNOWN", GPGME_VALIDITY_UNKNOWN TSRMLS_CC);
gnupg_declare_long_constant("VALIDITY_UNDEFINED", GPGME_VALIDITY_UNDEFINED TSRMLS_CC);
gnupg_declare_long_constant("VALIDITY_NEVER", GPGME_VALIDITY_NEVER TSRMLS_CC);
gnupg_declare_long_constant("VALIDITY_MARGINAL", GPGME_VALIDITY_MARGINAL TSRMLS_CC);
gnupg_declare_long_constant("VALIDITY_FULL", GPGME_VALIDITY_FULL TSRMLS_CC);
gnupg_declare_long_constant("VALIDITY_ULTIMATE", GPGME_VALIDITY_ULTIMATE TSRMLS_CC);
gnupg_declare_long_constant("PROTOCOL_OpenPGP", GPGME_PROTOCOL_OpenPGP TSRMLS_CC);
gnupg_declare_long_constant("PROTOCOL_CMS", GPGME_PROTOCOL_CMS TSRMLS_CC);
gnupg_declare_long_constant("SIGSUM_VALID", GPGME_SIGSUM_VALID TSRMLS_CC);
gnupg_declare_long_constant("SIGSUM_GREEN", GPGME_SIGSUM_GREEN TSRMLS_CC);
gnupg_declare_long_constant("SIGSUM_RED", GPGME_SIGSUM_RED TSRMLS_CC);
gnupg_declare_long_constant("SIGSUM_KEY_REVOKED", GPGME_SIGSUM_KEY_REVOKED TSRMLS_CC);
gnupg_declare_long_constant("SIGSUM_KEY_EXPIRED", GPGME_SIGSUM_KEY_EXPIRED TSRMLS_CC);
gnupg_declare_long_constant("SIGSUM_SIG_EXPIRED", GPGME_SIGSUM_SIG_EXPIRED TSRMLS_CC);
gnupg_declare_long_constant("SIGSUM_KEY_MISSING", GPGME_SIGSUM_KEY_MISSING TSRMLS_CC);
gnupg_declare_long_constant("SIGSUM_CRL_MISSING", GPGME_SIGSUM_CRL_MISSING TSRMLS_CC);
gnupg_declare_long_constant("SIGSUM_CRL_TOO_OLD", GPGME_SIGSUM_CRL_TOO_OLD TSRMLS_CC);
gnupg_declare_long_constant("SIGSUM_BAD_POLICY", GPGME_SIGSUM_BAD_POLICY TSRMLS_CC);
gnupg_declare_long_constant("SIGSUM_SYS_ERROR", GPGME_SIGSUM_SYS_ERROR TSRMLS_CC);
gnupg_declare_long_constant("ERROR_WARNING", 1 TSRMLS_CC);
gnupg_declare_long_constant("ERROR_EXCEPTION", 2 TSRMLS_CC);
gnupg_declare_long_constant("ERROR_SILENT", 3 TSRMLS_CC);
#endif
REGISTER_LONG_CONSTANT("GNUPG_SIG_MODE_NORMAL", GPGME_SIG_MODE_NORMAL, CONST_CS | CONST_PERSISTENT);
REGISTER_LONG_CONSTANT("GNUPG_SIG_MODE_DETACH", GPGME_SIG_MODE_DETACH, CONST_CS | CONST_PERSISTENT);
REGISTER_LONG_CONSTANT("GNUPG_SIG_MODE_CLEAR", GPGME_SIG_MODE_CLEAR, CONST_CS | CONST_PERSISTENT);
REGISTER_LONG_CONSTANT("GNUPG_VALIDITY_UNKNOWN", GPGME_VALIDITY_UNKNOWN, CONST_CS | CONST_PERSISTENT);
REGISTER_LONG_CONSTANT("GNUPG_VALIDITY_UNDEFINED", GPGME_VALIDITY_UNDEFINED, CONST_CS | CONST_PERSISTENT);
REGISTER_LONG_CONSTANT("GNUPG_VALIDITY_NEVER", GPGME_VALIDITY_NEVER, CONST_CS | CONST_PERSISTENT);
REGISTER_LONG_CONSTANT("GNUPG_VALIDITY_MARGINAL", GPGME_VALIDITY_MARGINAL, CONST_CS | CONST_PERSISTENT);
REGISTER_LONG_CONSTANT("GNUPG_VALIDITY_FULL", GPGME_VALIDITY_FULL, CONST_CS | CONST_PERSISTENT);
REGISTER_LONG_CONSTANT("GNUPG_VALIDITY_ULTIMATE", GPGME_VALIDITY_ULTIMATE, CONST_CS | CONST_PERSISTENT);
REGISTER_LONG_CONSTANT("GNUPG_PROTOCOL_OpenPGP", GPGME_PROTOCOL_OpenPGP, CONST_CS | CONST_PERSISTENT);
REGISTER_LONG_CONSTANT("GNUPG_PROTOCOL_CMS", GPGME_PROTOCOL_CMS, CONST_CS | CONST_PERSISTENT);
REGISTER_LONG_CONSTANT("GNUPG_SIGSUM_VALID", GPGME_SIGSUM_VALID, CONST_CS | CONST_PERSISTENT);
REGISTER_LONG_CONSTANT("GNUPG_SIGSUM_GREEN", GPGME_SIGSUM_GREEN, CONST_CS | CONST_PERSISTENT);
REGISTER_LONG_CONSTANT("GNUPG_SIGSUM_RED", GPGME_SIGSUM_RED, CONST_CS | CONST_PERSISTENT);
REGISTER_LONG_CONSTANT("GNUPG_SIGSUM_KEY_REVOKED", GPGME_SIGSUM_KEY_REVOKED, CONST_CS | CONST_PERSISTENT);
REGISTER_LONG_CONSTANT("GNUPG_SIGSUM_KEY_EXPIRED", GPGME_SIGSUM_KEY_EXPIRED, CONST_CS | CONST_PERSISTENT);
REGISTER_LONG_CONSTANT("GNUPG_SIGSUM_SIG_EXPIRED", GPGME_SIGSUM_SIG_EXPIRED, CONST_CS | CONST_PERSISTENT);
REGISTER_LONG_CONSTANT("GNUPG_SIGSUM_KEY_MISSING", GPGME_SIGSUM_KEY_MISSING, CONST_CS | CONST_PERSISTENT);
REGISTER_LONG_CONSTANT("GNUPG_SIGSUM_CRL_MISSING", GPGME_SIGSUM_CRL_MISSING, CONST_CS | CONST_PERSISTENT);
REGISTER_LONG_CONSTANT("GNUPG_SIGSUM_CRL_TOO_OLD", GPGME_SIGSUM_CRL_TOO_OLD, CONST_CS | CONST_PERSISTENT);
REGISTER_LONG_CONSTANT("GNUPG_SIGSUM_BAD_POLICY", GPGME_SIGSUM_BAD_POLICY, CONST_CS | CONST_PERSISTENT);
REGISTER_LONG_CONSTANT("GNUPG_SIGSUM_SYS_ERROR", GPGME_SIGSUM_SYS_ERROR, CONST_CS | CONST_PERSISTENT);
REGISTER_LONG_CONSTANT("GNUPG_ERROR_WARNING", 1, CONST_CS | CONST_PERSISTENT);
REGISTER_LONG_CONSTANT("GNUPG_ERROR_EXCEPTION", 2, CONST_CS | CONST_PERSISTENT);
REGISTER_LONG_CONSTANT("GNUPG_ERROR_SILENT", 3, CONST_CS | CONST_PERSISTENT);
return SUCCESS;
}
/* }}} */
/* {{{ PHP_MSHUTDOWN_FUNCTION
*/
PHP_MSHUTDOWN_FUNCTION(gnupg)
{
return SUCCESS;
}
/* }}} */
/* {{{ PHP_MINFO_FUNCTION
*/
PHP_MINFO_FUNCTION(gnupg)
{
php_info_print_table_start();
php_info_print_table_header(2, "gnupg support", "enabled");
php_info_print_table_row(2,"GPGme Version",gpgme_check_version(NULL));
php_info_print_table_row(2,"Extension Version",PHP_GNUPG_VERSION);
php_info_print_table_end();
}
/* }}} */
/* {{{ callback func for setting the passphrase */
gpgme_error_t passphrase_cb (gnupg_object *intern, const char *uid_hint, const char *passphrase_info,int last_was_bad, int fd TSRMLS_DC){
char uid[17];
int idx;
char *passphrase = NULL;
zval *return_value = NULL;
if(last_was_bad){
GNUPG_ERR("Incorrent passphrase");
return 1;
}
for(idx=0;idx<16;idx++){
uid[idx] = uid_hint[idx];
}
uid[16] = '\0';
if(zend_hash_find(intern->signkeys,(char *) uid,17,(void **) &passphrase)==FAILURE){
GNUPG_ERR("no passphrase set");
return 1;
}
if(!passphrase){
GNUPG_ERR("no passphrase set");
return 1;
}
if (write (fd, passphrase, strlen(passphrase))==strlen(passphrase)
&& write (fd, "\n", 1)==1) {
return 0;
}
GNUPG_ERR("write failed");
return 1;
}
gpgme_error_t passphrase_decrypt_cb (gnupg_object *intern, const char *uid_hint, const char *passphrase_info,int last_was_bad, int fd TSRMLS_DC){
char uid[17];
int idx;
char *passphrase = NULL;
zval *return_value = NULL;
if(last_was_bad){
GNUPG_ERR("Incorrent passphrase");
return 1;
}
for(idx=0;idx<16;idx++){
uid[idx] = uid_hint[idx];
}
uid[16] = '\0';
if(zend_hash_find(intern->decryptkeys,(char *) uid,17,(void **) &passphrase)==FAILURE){
GNUPG_ERR("no passphrase set");
return 1;
}
if(!passphrase){
GNUPG_ERR("no passphrase set");
return 1;
}
if (write (fd, passphrase, strlen(passphrase))==strlen(passphrase)
&& write (fd, "\n", 1)==1) {
return 0;
}
GNUPG_ERR("write failed");
return 1;
}
/* }}} */
/* {{{ gnupg_fetchsignatures */
int gnupg_fetchsignatures(gpgme_signature_t gpgme_signatures, zval *main_arr){
zval *sig_arr;
array_init (main_arr);
while(gpgme_signatures){
ALLOC_INIT_ZVAL (sig_arr);
array_init (sig_arr);
add_assoc_string (sig_arr, "fingerprint", gpgme_signatures->fpr, 1);
add_assoc_long (sig_arr, "validity", gpgme_signatures->validity );
add_assoc_long (sig_arr, "timestamp", gpgme_signatures->timestamp );
add_assoc_long (sig_arr, "status", gpgme_signatures->status );
add_assoc_long (sig_arr, "summary", gpgme_signatures->summary );
add_next_index_zval (main_arr, sig_arr);
gpgme_signatures = gpgme_signatures->next;
}
return 1;
}
/* }}} */
/* {{{ proto resource gnupg_init()
* inits gnupg and returns a resource
*/
PHP_FUNCTION(gnupg_init){
gnupg_object *intern;
intern = emalloc(sizeof(gnupg_object));
gnupg_res_init(intern TSRMLS_CC);
ZEND_REGISTER_RESOURCE(return_value,intern,le_gnupg);
}
/* }}} */
/* {{{ proto bool gnupg_setarmor(int armor)
* turn on/off armor mode
* 0 = off
* >0 = on
* */
PHP_FUNCTION(gnupg_setarmor){
long armor;
GNUPG_GETOBJ();
if(this){
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &armor) == FAILURE){
return;
}
}else{
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rl", &res, &armor) == FAILURE){
return;
}
ZEND_FETCH_RESOURCE(intern,gnupg_object *, &res, -1, "ctx", le_gnupg);
}
if(armor > 1){
armor = 1; /*just to make sure */
}
gpgme_set_armor (intern->ctx,armor);
RETURN_TRUE;
}
/* }}} */
/* {{{ proto bool gnupg_seterrormode(int errormde) */
PHP_FUNCTION(gnupg_seterrormode){
long errormode;
GNUPG_GETOBJ();
if(this){
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &errormode) == FAILURE){
return;
}
}else{
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rl", &res, &errormode) == FAILURE){
return;
}
ZEND_FETCH_RESOURCE(intern,gnupg_object *, &res, -1, "ctx", le_gnupg);
}
switch(errormode){
case 1: /* warning */
case 3: /* silent */
intern->errormode = errormode;
break;
#ifdef ZEND_ENGINE_2
case 2: /* exception */
intern->errormode = errormode;
break;
#endif
default:
GNUPG_ERR("invalid errormode");
}
}
/* }}} */
/* {{{ proto bool gnupg_setsignmode(int signmode)
* sets the mode for signing operations
*/
PHP_FUNCTION(gnupg_setsignmode){
long signmode;
GNUPG_GETOBJ();
if(this){
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &signmode) == FAILURE){
return;
}
}else{
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rl", &res, &signmode) == FAILURE){
return;
}
ZEND_FETCH_RESOURCE(intern,gnupg_object *, &res, -1, "ctx", le_gnupg);
}
switch(signmode){
case GPGME_SIG_MODE_NORMAL:
case GPGME_SIG_MODE_DETACH:
case GPGME_SIG_MODE_CLEAR:
intern->signmode = signmode;
RETVAL_TRUE;
break;
default:
GNUPG_ERR("invalid signmode");
RETVAL_FALSE;
break;
}
}
/* }}} */
/* {{{ proto string gnupg_geterror(void)
* returns the last errormessage
*/
PHP_FUNCTION(gnupg_geterror){
GNUPG_GETOBJ();
if(!this){
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &res) == FAILURE){
return;
}
ZEND_FETCH_RESOURCE(intern,gnupg_object *, &res, -1, "ctx", le_gnupg);
}
if(!intern->errortxt){
RETURN_FALSE;
}else{
RETURN_STRINGL(intern->errortxt, strlen(intern->errortxt), 1);
}
}
/* }}} */
/* {{{ proto int gnupg_getprotocol(void)
* returns the currently used pgp-protocol.
* atm only OpenPGP is supported
*/
PHP_FUNCTION(gnupg_getprotocol){
RETURN_LONG(GPGME_PROTOCOL_OpenPGP);
}
/* }}} */
/* {{{ proto array gnupg_keyinfo(string pattern)
* returns an array with informations about all keys, that matches the given pattern
*/
PHP_FUNCTION(gnupg_keyinfo)
{
char *searchkey = NULL;
int *searchkey_len;
zval *subarr;
zval *userid;
zval *userids;
zval *subkey;
zval *subkeys;
gpgme_key_t gpgme_key;
gpgme_subkey_t gpgme_subkey;
gpgme_user_id_t gpgme_userid;
GNUPG_GETOBJ();
if(this){
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &searchkey, &searchkey_len) == FAILURE){
return;
}
}else{
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs", &res, &searchkey, &searchkey_len) == FAILURE){
return;
}
ZEND_FETCH_RESOURCE(intern,gnupg_object *, &res, -1, "ctx", le_gnupg);
}
if((intern->err = gpgme_op_keylist_start(intern->ctx, searchkey, 0)) != GPG_ERR_NO_ERROR){
GNUPG_ERR("could not init keylist");
return;
}
array_init(return_value);
while(!(intern->err = gpgme_op_keylist_next(intern->ctx, &gpgme_key))){
ALLOC_INIT_ZVAL (subarr);
array_init (subarr);
ALLOC_INIT_ZVAL (subkeys);
array_init (subkeys);
ALLOC_INIT_ZVAL (userids);
array_init (userids);
add_assoc_bool (subarr, "disabled", gpgme_key->disabled );
add_assoc_bool (subarr, "expired", gpgme_key->expired );
add_assoc_bool (subarr, "revoked", gpgme_key->revoked );
add_assoc_bool (subarr, "is_secret", gpgme_key->secret );
add_assoc_bool (subarr, "can_sign", gpgme_key->can_sign );
add_assoc_bool (subarr, "can_encrypt", gpgme_key->can_encrypt );
gpgme_userid = gpgme_key->uids;
while(gpgme_userid){
ALLOC_INIT_ZVAL (userid);
array_init (userid);
add_assoc_string (userid, "name", gpgme_userid->name, 1);
add_assoc_string (userid, "comment", gpgme_userid->comment, 1);
add_assoc_string (userid, "email", gpgme_userid->email, 1);
add_assoc_string (userid, "uid", gpgme_userid->uid, 1);
add_assoc_bool (userid, "revoked", gpgme_userid->revoked );
add_assoc_bool (userid, "invalid", gpgme_userid->invalid );
add_next_index_zval (userids, userid);
gpgme_userid = gpgme_userid->next;
}
add_assoc_zval (subarr, "uids", userids);
gpgme_subkey = gpgme_key->subkeys;
while(gpgme_subkey){
ALLOC_INIT_ZVAL (subkey);
array_init (subkey);
if(gpgme_subkey->fpr){
add_assoc_string (subkey, "fingerprint", gpgme_subkey->fpr, 1);
}
add_assoc_string (subkey, "keyid", gpgme_subkey->keyid, 1);
add_assoc_long (subkey, "timestamp", gpgme_subkey->timestamp );
add_assoc_long (subkey, "expires", gpgme_subkey->expires );
add_assoc_bool (subkey, "is_secret", gpgme_subkey->secret );
add_assoc_bool (subkey, "invalid", gpgme_subkey->invalid );
add_assoc_bool (subkey, "can_encrypt", gpgme_subkey->can_encrypt );
add_assoc_bool (subkey, "can_sign", gpgme_subkey->can_sign );
add_assoc_bool (subkey, "disabled", gpgme_subkey->disabled );
add_assoc_bool (subkey, "expired", gpgme_subkey->expired );
add_assoc_bool (subkey, "revoked", gpgme_subkey->revoked );
add_next_index_zval (subkeys, subkey);
gpgme_subkey = gpgme_subkey->next;
}
add_assoc_zval (subarr, "subkeys", subkeys);
add_next_index_zval (return_value, subarr);
gpgme_key_unref (gpgme_key);
}
return;
}
/* }}} */
/* {{{ proto bool gnupg_addsignkey(string key) */
PHP_FUNCTION(gnupg_addsignkey){
char *key_id = NULL;
int key_id_len;
char *passphrase = NULL;
int passphrase_len;
gpgme_key_t gpgme_key;
gpgme_subkey_t gpgme_subkey;
GNUPG_GETOBJ();
if(this){
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|s", &key_id, &key_id_len, &passphrase, &passphrase_len) == FAILURE){
return;
}
}else{
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs|s", &res, &key_id, &key_id_len, &passphrase, &passphrase_len) == FAILURE){
return;
}
ZEND_FETCH_RESOURCE(intern,gnupg_object *, &res, -1, "ctx", le_gnupg);
}
if((intern->err = gpgme_get_key(intern->ctx, key_id, &gpgme_key, 1)) != GPG_ERR_NO_ERROR){
GNUPG_ERR("get_key failed");
return;
}
if(passphrase){
gpgme_subkey = gpgme_key->subkeys;
while(gpgme_subkey){
if(gpgme_subkey->can_sign == 1){
zend_hash_add(intern->signkeys, (char *) gpgme_subkey->keyid, (uint) strlen(gpgme_subkey->keyid)+1, passphrase, (uint) passphrase_len+1, NULL);
}
gpgme_subkey = gpgme_subkey->next;
}
}
if((intern->err = gpgme_signers_add(intern->ctx, gpgme_key))!=GPG_ERR_NO_ERROR){
GNUPG_ERR("could not add signer");
}else{
RETVAL_TRUE;
}
gpgme_key_unref(gpgme_key);
}
/* }}} */
/* {{{ proto bool gnupg_adddecryptkey(string key) */
PHP_FUNCTION(gnupg_adddecryptkey){
char *key_id = NULL;
int key_id_len;
char *passphrase = NULL;
int passphrase_len;
gpgme_key_t gpgme_key;
gpgme_subkey_t gpgme_subkey;
GNUPG_GETOBJ();
if(this){
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss", &key_id, &key_id_len, &passphrase, &passphrase_len) == FAILURE){
return;
}
}else{
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rss", &res, &key_id, &key_id_len, &passphrase, &passphrase_len) == FAILURE){
return;
}
ZEND_FETCH_RESOURCE(intern,gnupg_object *, &res, -1, "ctx", le_gnupg);
}
if((intern->err = gpgme_get_key(intern->ctx, key_id, &gpgme_key, 1)) != GPG_ERR_NO_ERROR){
GNUPG_ERR("get_key failed");
return;
}
gpgme_subkey = gpgme_key->subkeys;
while(gpgme_subkey){
if(gpgme_subkey->secret == 1){
zend_hash_add(intern->decryptkeys, (char *) gpgme_subkey->keyid, (uint) strlen(gpgme_subkey->keyid)+1, passphrase, (uint) passphrase_len+1, NULL);
}
gpgme_subkey = gpgme_subkey->next;
}
gpgme_key_unref(gpgme_key);
RETURN_TRUE;
}
/* }}} */
/* {{{ proto bool gnupg_addencryptkey(string key) */
PHP_FUNCTION(gnupg_addencryptkey){
char *key_id = NULL;
int key_id_len;
gpgme_key_t gpgme_key = NULL;
GNUPG_GETOBJ();
if(this){
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &key_id, &key_id_len) == FAILURE){
return;
}
}else{
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs", &res, &key_id, &key_id_len) == FAILURE){
return;
}
ZEND_FETCH_RESOURCE(intern,gnupg_object *, &res, -1, "ctx", le_gnupg);
}
if((intern->err = gpgme_get_key(intern->ctx, key_id, &gpgme_key, 0)) != GPG_ERR_NO_ERROR){
GNUPG_ERR("get_key failed");
return;
}
intern->encryptkeys = erealloc(intern->encryptkeys, sizeof(intern->encryptkeys) * (intern->encrypt_size + 2));
intern->encryptkeys[intern->encrypt_size] = gpgme_key;
intern->encrypt_size++;
intern->encryptkeys[intern->encrypt_size] = NULL;
RETURN_TRUE;
}
/* }}} */
/* {{{ proto bool gnupg_clearsignerkeys(void)
* removes all keys which are set for signing
*/
PHP_FUNCTION(gnupg_clearsignkeys){
GNUPG_GETOBJ();
if(!this){
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &res) == FAILURE){
return;
}
ZEND_FETCH_RESOURCE(intern,gnupg_object *, &res, -1, "ctx", le_gnupg);
}
gpgme_signers_clear (intern->ctx);
zend_hash_clean(intern->signkeys);
RETURN_TRUE;
}
/* }}} */
/* {{{ proto bool gnupg_clearencryptkeys(void)
* removes all keys which are set for encryption
*/
PHP_FUNCTION(gnupg_clearencryptkeys){
GNUPG_GETOBJ();
if(!this){
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &res) == FAILURE){
return;
}
ZEND_FETCH_RESOURCE(intern,gnupg_object *, &res, -1, "ctx", le_gnupg);
}
gnupg_free_encryptkeys(intern TSRMLS_CC);
RETURN_TRUE;
}
/* }}} */
/* {{{ proto bool gnupg_clearsignerkeys(void)
* removes all keys which are set for signing
*/
PHP_FUNCTION(gnupg_cleardecryptkeys){
GNUPG_GETOBJ();
if(!this){
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &res) == FAILURE){
return;
}
ZEND_FETCH_RESOURCE(intern,gnupg_object *, &res, -1, "ctx", le_gnupg);
}
zend_hash_clean(intern->decryptkeys);
RETURN_TRUE;
}
/* }}} */
/* {{{ proto string gnupg_sign(string text)
* signs the given test with the key, which was set with setsignerkey before
* and returns the signed text
* the signmode depends on gnupg_setsignmode
*/
PHP_FUNCTION(gnupg_sign){
char *value = NULL;
int value_len;
char *userret;
size_t ret_size;
gpgme_data_t in, out;
gpgme_sign_result_t result;
GNUPG_GETOBJ();
if(this){
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &value, &value_len) == FAILURE){
return;
}
}else{
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs", &res, &value, &value_len) == FAILURE){
return;
}
ZEND_FETCH_RESOURCE(intern,gnupg_object *, &res, -1, "ctx", le_gnupg);
}
gpgme_set_passphrase_cb (intern->ctx, (void*) passphrase_cb, intern);
if((intern->err = gpgme_data_new_from_mem (&in, value, value_len, 0))!=GPG_ERR_NO_ERROR){
GNUPG_ERR("could not create in-data buffer");
return;
}
if((intern->err = gpgme_data_new(&out))!=GPG_ERR_NO_ERROR){
GNUPG_ERR("could not create out-data buffer");
gpgme_data_release(in);
return;
}
if((intern->err = gpgme_op_sign(intern->ctx, in, out, intern->signmode))!=GPG_ERR_NO_ERROR){
if(!intern->errortxt){
GNUPG_ERR("data signing failed");
}
gpgme_data_release(in);
gpgme_data_release(out);
RETVAL_FALSE;
return;
}
result = gpgme_op_sign_result (intern->ctx);
if(result->invalid_signers){
GNUPG_ERR("invalid signers found");
gpgme_data_release(in);
gpgme_data_release(out);
return;
}
if(!result->signatures){
GNUPG_ERR("no signature in result");
gpgme_data_release(in);
gpgme_data_release(out);
return;
}
userret = gpgme_data_release_and_get_mem(out,&ret_size);
if(ret_size < 1){
RETVAL_FALSE;
}else{
RETVAL_STRINGL (userret,ret_size,1);
}
gpgme_data_release (in);
free (userret);
}
/* }}} */
/* {{{ proto string gnupg_encrypt(string text)
* encrypts the given text with the key, which was set with setencryptkey before
* and returns the encrypted text
*/
PHP_FUNCTION(gnupg_encrypt){
char *value = NULL;
int value_len;
char *userret = NULL;
size_t ret_size;
gpgme_data_t in, out;
gpgme_encrypt_result_t result;
GNUPG_GETOBJ();
if(this){
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &value, &value_len) == FAILURE){
return;
}
}else{
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs", &res, &value, &value_len) == FAILURE){
return;
}
ZEND_FETCH_RESOURCE(intern,gnupg_object *, &res, -1, "ctx", le_gnupg);
}
if(!intern->encryptkeys){
GNUPG_ERR("no key for encryption set");
return;
}
if((intern->err = gpgme_data_new_from_mem (&in, value, value_len, 0))!=GPG_ERR_NO_ERROR){
GNUPG_ERR("could no create in-data buffer");
return;
}
if((intern->err = gpgme_data_new(&out))!=GPG_ERR_NO_ERROR){
GNUPG_ERR("could not create out-data buffer");
gpgme_data_release(in);
return;
}
if((intern->err = gpgme_op_encrypt(intern->ctx, intern->encryptkeys, GPGME_ENCRYPT_ALWAYS_TRUST, in, out))!=GPG_ERR_NO_ERROR){
GNUPG_ERR("encrypt failed");
gpgme_data_release(in);
gpgme_data_release(out);
return;
}
result = gpgme_op_encrypt_result (intern->ctx);
if (result->invalid_recipients){
GNUPG_ERR("Invalid recipient encountered");
gpgme_data_release(in);
gpgme_data_release(out);
return;
}
userret = gpgme_data_release_and_get_mem(out,&ret_size);
gpgme_data_release (in);
RETVAL_STRINGL (userret,ret_size,1);
free (userret);
if(ret_size < 1){
RETURN_FALSE;
}
}
/* }}} */
/* {{{ proto string gnupg_encrypt_sign(string text)
* encrypts and signs the given text with the keys, which weres set with setencryptkey and setsignkey before
* and returns the encrypted text
*/
PHP_FUNCTION(gnupg_encryptsign){
char *value = NULL;
int value_len;
char *userret = NULL;
size_t ret_size;
gpgme_data_t in, out;
gpgme_encrypt_result_t result;
gpgme_sign_result_t sign_result;
GNUPG_GETOBJ();
if(this){
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &value, &value_len) == FAILURE){
return;
}
}else{
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs", &res, &value, &value_len) == FAILURE){
return;
}
ZEND_FETCH_RESOURCE(intern,gnupg_object *, &res, -1, "ctx", le_gnupg);
}
if(!intern->encryptkeys){
GNUPG_ERR("no key for encryption set");
return;
}
gpgme_set_passphrase_cb (intern->ctx, (void*) passphrase_cb, intern);
if((intern->err = gpgme_data_new_from_mem (&in, value, value_len, 0))!=GPG_ERR_NO_ERROR){
GNUPG_ERR("could not create in-data buffer");
return;
}
if((intern->err = gpgme_data_new(&out))!=GPG_ERR_NO_ERROR){
GNUPG_ERR("could not create out-data buffer");
gpgme_data_release(in);
return;
}
if((intern->err = gpgme_op_encrypt_sign(intern->ctx, intern->encryptkeys, GPGME_ENCRYPT_ALWAYS_TRUST, in, out))!=GPG_ERR_NO_ERROR){
if(!intern->errortxt){
GNUPG_ERR("encrypt-sign failed");
}
gpgme_data_release(in);
gpgme_data_release(out);
RETVAL_FALSE;
return;
}
result = gpgme_op_encrypt_result (intern->ctx);
if (result->invalid_recipients){
GNUPG_ERR("Invalid recipient encountered");
gpgme_data_release(in);
gpgme_data_release(out);
return;
}
sign_result = gpgme_op_sign_result (intern->ctx);
if(sign_result->invalid_signers){
GNUPG_ERR("invalid signers found");
gpgme_data_release(in);
gpgme_data_release(out);
return;
}
if(!sign_result->signatures){
GNUPG_ERR("could not find a signature");
gpgme_data_release(in);
gpgme_data_release(out);
return;
}
userret = gpgme_data_release_and_get_mem(out,&ret_size);
gpgme_data_release (in);
RETVAL_STRINGL (userret,ret_size,1);
free (userret);
if(ret_size < 1){
RETURN_FALSE;
}
}
/* }}} */
/* {{{ proto array gnupg_verify(string text, string signature [, string &plaintext])
* verifies the given clearsigned text and returns information about the result in an array
*/
PHP_FUNCTION(gnupg_verify){
gpgme_data_t gpgme_text, gpgme_sig;
gpgme_verify_result_t gpgme_result;
zval *signed_text = NULL; /* text without the signature, if its a detached one, or the text incl the sig */
zval *signature = NULL; /* signature, if its a detached one */
zval *plain_text = NULL; /* signed_text without the signature if its not a detached sig */
char *gpg_plain;
size_t gpg_plain_len;
GNUPG_GETOBJ();
if(this){
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz|z", &signed_text, &signature, &plain_text) == FAILURE){
return;
}
}else{
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rzz|z", &res, &signed_text, &signature, &plain_text) == FAILURE){
return;
}
ZEND_FETCH_RESOURCE(intern,gnupg_object *, &res, -1, "ctx", le_gnupg);
}
if(Z_STRVAL_P(signature)){ /* detached signature */
/* setup signature-databuffer for gpgme */
if((intern->err = gpgme_data_new_from_mem (&gpgme_sig, Z_STRVAL_P(signature), Z_STRLEN_P(signature), 0))!=GPG_ERR_NO_ERROR){
GNUPG_ERR ("could not create signature-databuffer");
return;
}
/* and the text */
if((intern->err = gpgme_data_new_from_mem (&gpgme_text, Z_STRVAL_P(signed_text), Z_STRLEN_P(signed_text), 0))!=GPG_ERR_NO_ERROR){
GNUPG_ERR ("could not create text-databuffer");
gpgme_data_release (gpgme_sig);
gpgme_data_release (gpgme_text);
return;
}
/* now verify sig + text */
if((intern->err = gpgme_op_verify (intern->ctx, gpgme_sig, gpgme_text, NULL))!=GPG_ERR_NO_ERROR){
GNUPG_ERR ("verify failed");
gpgme_data_release (gpgme_sig);
gpgme_data_release (gpgme_text);
return;
}
}else{ /* clearsign or normal signature */
if((intern->err = gpgme_data_new_from_mem (&gpgme_sig, Z_STRVAL_P(signed_text), Z_STRLEN_P(signed_text), 0))!=GPG_ERR_NO_ERROR){
GNUPG_ERR ("could not create signature-databuffer");
return;
}
/* set a NULL databuffer for gpgme */
if((intern->err = gpgme_data_new_from_mem (&gpgme_text, NULL, 0, 0))!=GPG_ERR_NO_ERROR){
GNUPG_ERR ("could not create text-databuffer");
gpgme_data_release (gpgme_sig);
gpgme_data_release (gpgme_text);
return;
}
/* and verify the 'signature' */
if((intern->err = gpgme_op_verify (intern->ctx, gpgme_sig, NULL, gpgme_text))!=GPG_ERR_NO_ERROR){
GNUPG_ERR ("verify failed");
gpgme_data_release (gpgme_sig);
gpgme_data_release (gpgme_text);
return;
}
}
/* now get the result */
gpgme_result = gpgme_op_verify_result (intern->ctx);
if(!gpgme_result->signatures){
GNUPG_ERR ("no signature found");
}else{
/* fetch all signatures in an array */
gnupg_fetchsignatures (gpgme_result->signatures, return_value);
/* get a 'plain' version of the text without a signature */
gpg_plain = gpgme_data_release_and_get_mem(gpgme_text,&gpg_plain_len);
if(gpg_plain && gpg_plain_len > 0 && plain_text){
ZVAL_STRINGL (plain_text, gpg_plain,gpg_plain_len,1);
}
free (gpg_plain);
}
gpgme_data_release (gpgme_sig);
}
/* }}} */
/* {{{ proto string gnupg_decrypt(string enctext)
* decrypts the given enctext
*/
PHP_FUNCTION(gnupg_decrypt){
char *enctxt;
int enctxt_len;
char *userret;
size_t ret_size;
gpgme_data_t in, out;
gpgme_decrypt_result_t result;
GNUPG_GETOBJ();
if(this){
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &enctxt, &enctxt_len) == FAILURE){
return;
}
}else{
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs", &res, &enctxt, &enctxt_len) == FAILURE){
return;
}
ZEND_FETCH_RESOURCE(intern,gnupg_object *, &res, -1, "ctx", le_gnupg);
}
gpgme_set_passphrase_cb (intern->ctx, (void*) passphrase_decrypt_cb, intern);
if((intern->err = gpgme_data_new_from_mem (&in, enctxt, enctxt_len, 0))!=GPG_ERR_NO_ERROR){
GNUPG_ERR("could not create in-data buffer");
}
if((intern->err = gpgme_data_new (&out))!=GPG_ERR_NO_ERROR){
GNUPG_ERR("could not create out-data buffer");
gpgme_data_release(in);
return;
}
if((intern->err = gpgme_op_decrypt (intern->ctx, in, out))!=GPG_ERR_NO_ERROR){
if(!intern->errortxt){
GNUPG_ERR("decrypt failed");
}
gpgme_data_release(in);
gpgme_data_release(out);
RETVAL_FALSE;
return;
}
result = gpgme_op_decrypt_result (intern->ctx);
if (result->unsupported_algorithm){
GNUPG_ERR("unsupported algorithm");
gpgme_data_release(in);
gpgme_data_release(out);
return;
}
userret = gpgme_data_release_and_get_mem(out,&ret_size);
gpgme_data_release (in);
RETVAL_STRINGL (userret,ret_size,1);
free (userret);
if(ret_size < 1){
RETVAL_FALSE;
}
}
/* }}} */
/* {{{ proto string gnupg_decryptverify(string enctext, string &plaintext)
* decrypts the given enctext
*/
PHP_FUNCTION(gnupg_decryptverify){
char *enctxt;
int enctxt_len;
zval *plaintext;
char *userret;
size_t ret_size;
gpgme_data_t in, out;
gpgme_decrypt_result_t decrypt_result;
gpgme_verify_result_t verify_result;
GNUPG_GETOBJ();
if(this){
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sz", &enctxt, &enctxt_len, &plaintext) == FAILURE){
return;
}
}else{
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rsz", &res, &enctxt, &enctxt_len, &plaintext) == FAILURE){
return;
}
ZEND_FETCH_RESOURCE(intern,gnupg_object *, &res, -1, "ctx", le_gnupg);
}
gpgme_set_passphrase_cb (intern->ctx, (void*) passphrase_decrypt_cb, intern);
if((intern->err = gpgme_data_new_from_mem (&in, enctxt, enctxt_len, 0))!=GPG_ERR_NO_ERROR){
GNUPG_ERR("could not create in-data buffer");
}
if((intern->err = gpgme_data_new (&out))!=GPG_ERR_NO_ERROR){
GNUPG_ERR("could not create out-data buffer");
gpgme_data_release(in);
return;
}
if((intern->err = gpgme_op_decrypt_verify (intern->ctx, in, out))!=GPG_ERR_NO_ERROR){
if(!intern->errortxt){
GNUPG_ERR("decrypt-verify failed");
}
gpgme_data_release(in);
gpgme_data_release(out);
RETVAL_FALSE;
return;
}
userret = gpgme_data_release_and_get_mem(out,&ret_size);
ZVAL_STRINGL (plaintext,userret,ret_size,1);
free (userret);
decrypt_result = gpgme_op_decrypt_result (intern->ctx);
if (decrypt_result->unsupported_algorithm){
GNUPG_ERR ("unsupported algorithm");
gpgme_data_release(in);
return;
}
verify_result = gpgme_op_verify_result (intern->ctx);
if(!verify_result->signatures){
GNUPG_ERR ("no signature found");
gpgme_data_release(in);
free(out);
return;
}
gnupg_fetchsignatures (verify_result->signatures, return_value);
gpgme_data_release (in);
}
/* }}} */
/* {{{ proto string gnupg_export(string pattern)
* exports the first public key which matches against the given pattern
*/
PHP_FUNCTION(gnupg_export){
char *searchkey = NULL;
int *searchkey_len;
char *userret;
size_t ret_size;
gpgme_data_t out;
GNUPG_GETOBJ();
if(this){
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &searchkey, &searchkey_len) == FAILURE){
return;
}
}else{
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs", &res, &searchkey, &searchkey_len) == FAILURE){
return;
}
ZEND_FETCH_RESOURCE(intern,gnupg_object *, &res, -1, "ctx", le_gnupg);
}
if((intern->err = gpgme_data_new (&out))!=GPG_ERR_NO_ERROR){
GNUPG_ERR("could not create data buffer");
return;
}
if((intern->err = gpgme_op_export (intern->ctx, searchkey, 0, out))!=GPG_ERR_NO_ERROR){
GNUPG_ERR("export failed");
gpgme_data_release(out);
return;
}
userret = gpgme_data_release_and_get_mem(out,&ret_size);
RETVAL_STRINGL (userret,ret_size,1);
if(ret_size < 1){
RETVAL_FALSE;
}
free(userret);
}
/* }}} */
/* {{{ proto array gnupg_import(string key)
* imports the given key and returns a status-array
*/
PHP_FUNCTION(gnupg_import){
char *importkey = NULL;
int importkey_len;
gpgme_data_t in;
gpgme_import_result_t result;
GNUPG_GETOBJ();
if(this){
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &importkey, &importkey_len) == FAILURE){
return;
}
}else{
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs", &res, &importkey, &importkey_len) == FAILURE){
return;
}
ZEND_FETCH_RESOURCE(intern,gnupg_object *, &res, -1, "ctx", le_gnupg);
}
if((intern->err = gpgme_data_new_from_mem (&in, importkey, importkey_len, 0))!=GPG_ERR_NO_ERROR){
GNUPG_ERR("could not create in-data buffer");
return;
}
if((intern->err = gpgme_op_import(intern->ctx,in))!=GPG_ERR_NO_ERROR){
GNUPG_ERR("import failed");
gpgme_data_release(in);
return;
}
gpgme_data_release(in);
result = gpgme_op_import_result (intern->ctx);
array_init (return_value);
add_assoc_long (return_value, "imported", result->imported);
add_assoc_long (return_value, "unchanged", result->unchanged);
add_assoc_long (return_value, "newuserids", result->new_user_ids);
add_assoc_long (return_value, "newsubkeys", result->new_sub_keys);
add_assoc_long (return_value, "secretimported", result->secret_imported);
add_assoc_long (return_value, "secretunchanged", result->secret_unchanged);
add_assoc_long (return_value, "newsignatures", result->new_signatures);
add_assoc_long (return_value, "skippedkeys", result->skipped_new_keys);
if(result->imports && result->imports->fpr){
add_assoc_string (return_value, "fingerprint", result->imports->fpr, 1);
}
}
/* }}} */
/* {{{ proto book gnupg_deletekey(string key)
* deletes a key from the keyring
*/
PHP_FUNCTION(gnupg_deletekey){
char *key;
int key_len;
long allow_secret = 0;
gpgme_key_t gpgme_key;
GNUPG_GETOBJ();
if(this){
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|l", &key, &key_len, &allow_secret) == FAILURE){
return;
}
}else{
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs|l", &res, &key, &key_len, &allow_secret) == FAILURE){
return;
}
ZEND_FETCH_RESOURCE(intern,gnupg_object *, &res, -1, "ctx", le_gnupg);
}
if((intern->err = gpgme_get_key(intern->ctx, key, &gpgme_key, 0)) != GPG_ERR_NO_ERROR){
GNUPG_ERR("get_key failed");
return;
}
if((intern->err = gpgme_op_delete(intern->ctx,gpgme_key,allow_secret))!=GPG_ERR_NO_ERROR){
GNUPG_ERR("delete failed");
RETVAL_FALSE;
}else{
RETVAL_TRUE;
}
gpgme_key_unref(gpgme_key);
}
/* }}} */
/* {{{ proto array gnupg_gettrustlist(string pattern)
* searching for trust items which match PATTERN
*/
PHP_FUNCTION(gnupg_gettrustlist){
char *pattern;
int pattern_len;
zval *sub_arr;
gpgme_trust_item_t item;
GNUPG_GETOBJ();
if(this){
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &pattern, &pattern_len) == FAILURE){
return;
}
}else{
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs", &res, &pattern, &pattern_len) == FAILURE){
return;
}
ZEND_FETCH_RESOURCE(intern,gnupg_object *, &res, -1, "ctx", le_gnupg);
}
if((intern->err = gpgme_op_trustlist_start (intern->ctx, pattern, 0))!=GPG_ERR_NO_ERROR){
GNUPG_ERR("could not start trustlist");
return;
}
array_init(return_value);
while (!(intern->err = gpgme_op_trustlist_next (intern->ctx, &item))){
ALLOC_INIT_ZVAL (sub_arr);
array_init (sub_arr);
add_assoc_long (sub_arr, "level", item->level );
add_assoc_long (sub_arr, "type", item->type );
add_assoc_string (sub_arr, "keyid", item->keyid, 1);
add_assoc_string (sub_arr, "ownertrust", item->owner_trust, 1);
add_assoc_string (sub_arr, "validity", item->validity, 1);
add_assoc_string (sub_arr, "name", item->name, 1);
gpgme_trust_item_unref (item);
add_next_index_zval (return_value, sub_arr);
}
}
/* }}} */
/* {{{ proto array gnupg_listsignatures(string keyid) */
PHP_FUNCTION(gnupg_listsignatures){
char *keyid;
int keyid_len;
zval *sub_arr;
zval *sig_arr;
gpgme_key_t gpgme_key;
gpgme_user_id_t gpgme_userid;
gpgme_key_sig_t gpgme_signature;
GNUPG_GETOBJ();
if(this){
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &keyid, &keyid_len) == FAILURE){
return;
}
}else{
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs", &res, &keyid, &keyid_len) == FAILURE){
return;
}
ZEND_FETCH_RESOURCE(intern,gnupg_object *, &res, -1, "ctx", le_gnupg);
}
if((intern->err = gpgme_set_keylist_mode(intern->ctx,GPGME_KEYLIST_MODE_SIGS))!=GPG_ERR_NO_ERROR){
GNUPG_ERR("could not switch to sigmode");
return;
}
if((intern->err = gpgme_get_key(intern->ctx, keyid, &gpgme_key, 0)) != GPG_ERR_NO_ERROR){
GNUPG_ERR("get_key failed. given key not unique?");
return;
}
if(!gpgme_key->uids){
GNUPG_ERR("no uids found");
gpgme_key_unref(gpgme_key);
return;
}
array_init(return_value);
gpgme_userid = gpgme_key->uids;
while(gpgme_userid){
ALLOC_INIT_ZVAL (sub_arr);
array_init (sub_arr);
gpgme_signature = gpgme_userid->signatures;
while(gpgme_signature){
ALLOC_INIT_ZVAL (sig_arr);
array_init (sig_arr);
add_assoc_string (sig_arr, "uid", gpgme_signature->uid, 1);
add_assoc_string (sig_arr, "name", gpgme_signature->name, 1);
add_assoc_string (sig_arr, "email", gpgme_signature->email, 1);
add_assoc_string (sig_arr, "comment", gpgme_signature->comment, 1);
add_assoc_long (sig_arr, "expires", gpgme_signature->expires );
add_assoc_bool (sig_arr, "revoked", gpgme_signature->revoked );
add_assoc_bool (sig_arr, "expired", gpgme_signature->expired );
add_assoc_bool (sig_arr, "invalid", gpgme_signature->invalid );
add_assoc_zval (sub_arr,gpgme_signature->keyid,sig_arr);
gpgme_signature = gpgme_signature->next;
}
add_assoc_zval (return_value,gpgme_userid->uid,sub_arr);
gpgme_userid = gpgme_userid->next;
}
gpgme_key_unref(gpgme_key);
}
/* }}} */
/*
* Local variables:
* tab-width: 4
* c-basic-offset: 4
* End:
* vim600: noet sw=4 ts=4 fdm=marker
* vim<600: noet sw=4 ts=4
*/
gnupg-1.3.3/gnupg_keylistiterator.c 0000644 0000765 0000024 00000012655 12171502055 014365 0 ustar /*
+--------------------------------------------------------------------+
| PECL :: gnupg |
+--------------------------------------------------------------------+
| Redistribution and use in source and binary forms, with or without |
| modification, are permitted provided that the conditions mentioned |
| in the accompanying LICENSE file are met. |
+--------------------------------------------------------------------+
| Copyright (c) 2006, Thilo Raufeisen |
| Copyright (c) 2013, Jim Jagielski |
+--------------------------------------------------------------------+
*/
/* $Id: gnupg_keylistiterator.c 330831 2013-07-09 13:12:55Z remi $ */
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include "php.h"
#ifdef ZEND_ENGINE_2
#include "php_ini.h"
#include "ext/standard/info.h"
#include "zend_interfaces.h"
#include "zend_exceptions.h"
#include "php_gnupg.h"
#include "php_gnupg_keylistiterator.h"
static int le_gnupg_keylistiterator;
static zend_object_handlers gnupg_keylistiterator_object_handlers;
/* {{{ defs */
#define GNUPG_GET_ITERATOR() \
zval *this = getThis(); \
gnupg_keylistiterator_object *intern = NULL; \
if(this){ \
intern = (gnupg_keylistiterator_object*) zend_object_store_get_object(getThis() TSRMLS_CC); \
if(!intern){ \
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid or unitialized gnupg object"); \
RETURN_FALSE; \
} \
}
/* }}} */
/* {{{ free_iterator_storage */
static void gnupg_keylistiterator_dtor(gnupg_keylistiterator_object *intern TSRMLS_DC){
if(!intern){
return;
}
gpgme_op_keylist_end(intern->ctx);
gpgme_key_release(intern->gpgkey);
gpgme_release(intern->ctx);
/*
zval_dtor(&intern->pattern);
*/
#if ZEND_MODULE_API_NO >= 20100525
intern->zo.properties_table = NULL;
#endif
if(intern->zo.properties){
zend_hash_destroy(intern->zo.properties);
FREE_HASHTABLE(intern->zo.properties);
}
efree(intern);
}
/* }}} */
/* {{{ keylistiterator_objects_new */
zend_object_value gnupg_keylistiterator_objects_new(zend_class_entry *class_type TSRMLS_DC){
gnupg_keylistiterator_object *intern;
zend_object_value retval;
gpgme_ctx_t ctx;
intern = emalloc(sizeof(gnupg_keylistiterator_object));
intern->zo.ce = class_type;
zend_object_std_init(&intern->zo, class_type TSRMLS_CC);
retval.handle = zend_objects_store_put(intern,NULL,(zend_objects_free_object_storage_t) gnupg_keylistiterator_dtor,NULL TSRMLS_CC);
retval.handlers = (zend_object_handlers *) & gnupg_keylistiterator_object_handlers;
gpgme_new(&ctx);
intern->ctx = ctx;
return retval;
}
/* }}} */
/* {{{ methodlist gnupg_keylistiterator */
static zend_function_entry gnupg_keylistiterator_methods[] = {
PHP_ME(gnupg_keylistiterator, __construct, NULL, ZEND_ACC_PUBLIC)
PHP_ME(gnupg_keylistiterator, current, NULL, ZEND_ACC_PUBLIC)
PHP_ME(gnupg_keylistiterator, key, NULL, ZEND_ACC_PUBLIC)
PHP_ME(gnupg_keylistiterator, next, NULL, ZEND_ACC_PUBLIC)
PHP_ME(gnupg_keylistiterator, rewind, NULL, ZEND_ACC_PUBLIC)
PHP_ME(gnupg_keylistiterator, valid, NULL, ZEND_ACC_PUBLIC)
{NULL, NULL, NULL}
};
/* }}} */
/* {{{ _gnupg_keylistiterator_init
*/
int _gnupg_keylistiterator_init(INIT_FUNC_ARGS)
{
zend_class_entry ce;
INIT_CLASS_ENTRY(ce, "gnupg_keylistiterator", gnupg_keylistiterator_methods);
ce.create_object = gnupg_keylistiterator_objects_new;
gnupg_keylistiterator_class_entry = zend_register_internal_class(&ce TSRMLS_CC);
memcpy(&gnupg_keylistiterator_object_handlers, zend_get_std_object_handlers(), sizeof(zend_object_handlers));
le_gnupg_keylistiterator = zend_register_list_destructors_ex(NULL, NULL, "ctx_keylistiterator", module_number);
zend_class_implements (gnupg_keylistiterator_class_entry TSRMLS_CC, 1, zend_ce_iterator);
return SUCCESS;
}
/* }}} */
PHP_METHOD(gnupg_keylistiterator,__construct){
zval *pattern;
int args = ZEND_NUM_ARGS();
GNUPG_GET_ITERATOR();
if(args > 0){
if (zend_parse_parameters(args TSRMLS_CC, "|z", &pattern) == FAILURE){
return;
}
intern->pattern = *pattern;
zval_copy_ctor(&intern->pattern);
}else{
ZVAL_EMPTY_STRING(&intern->pattern);
}
}
PHP_METHOD(gnupg_keylistiterator,current){
GNUPG_GET_ITERATOR();
RETURN_STRING(intern->gpgkey->uids[0].uid,1);
}
PHP_METHOD(gnupg_keylistiterator,key){
GNUPG_GET_ITERATOR();
RETURN_STRING(intern->gpgkey->subkeys[0].fpr,1);
}
PHP_METHOD(gnupg_keylistiterator,next){
GNUPG_GET_ITERATOR();
if(intern->gpgkey){
gpgme_key_release(intern->gpgkey);
}
if((intern->err = gpgme_op_keylist_next(intern->ctx, &intern->gpgkey))){
gpgme_key_release(intern->gpgkey);
intern->gpgkey = NULL;
}
RETURN_TRUE;
}
PHP_METHOD(gnupg_keylistiterator,rewind){
GNUPG_GET_ITERATOR();
if((intern->err = gpgme_op_keylist_start(intern->ctx, Z_STRVAL(intern->pattern), 0)) != GPG_ERR_NO_ERROR){
zend_throw_exception(zend_exception_get_default(TSRMLS_C),(char *)gpg_strerror(intern->err),1 TSRMLS_CC);
}
if((intern->err = gpgme_op_keylist_next(intern->ctx, &intern->gpgkey))!=GPG_ERR_NO_ERROR){
RETURN_FALSE;
}
RETURN_TRUE;
}
PHP_METHOD(gnupg_keylistiterator,valid){
GNUPG_GET_ITERATOR();
if(intern->gpgkey!=NULL){
RETURN_TRUE;
}else{
RETURN_FALSE;
}
}
#endif /* ZEND_ENGINE_2 */
/*
* Local variables:
* tab-width: 4
* c-basic-offset: 4
* End:
* vim600: noet sw=4 ts=4 fdm=marker
* vim<600: noet sw=4 ts=4
*/
gnupg-1.3.3/LICENSE 0000644 0000765 0000024 00000005055 12171502055 010564 0 ustar Copyright (c) 2005, Thilo Raufeisen .
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright notice,
this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
----
Copyright (c) 2013, Jim Jagielski .
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright notice,
this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
gnupg-1.3.3/php_gnupg.h 0000644 0000765 0000024 00000005025 12171502055 011714 0 ustar /*
+--------------------------------------------------------------------+
| PECL :: gnupg |
+--------------------------------------------------------------------+
| Redistribution and use in source and binary forms, with or without |
| modification, are permitted provided that the conditions mentioned |
| in the accompanying LICENSE file are met. |
+--------------------------------------------------------------------+
| Copyright (c) 2006, Thilo Raufeisen |
| Copyright (c) 2013, Jim Jagielski |
+--------------------------------------------------------------------+
*/
/* $Id: php_gnupg.h 330795 2013-07-08 14:11:30Z jimjag $ */
#ifndef PHP_GNUPG_H
#define PHP_GNUPG_H
extern zend_module_entry gnupg_module_entry;
#define phpext_gnupg_ptr &gnupg_module_entry
#define PHP_GNUPG_VERSION "1.3.3-dev"
#ifdef PHP_WIN32
#define PHP_GNUPG_API __declspec(dllexport)
#else
#define PHP_GNUPG_API
#endif
#ifdef ZTS
#include "TSRM.h"
#endif
#include
typedef struct gnupg_object{
zend_object zo;
gpgme_ctx_t ctx;
gpgme_error_t err;
int errormode;
char* errortxt;
int signmode;
gpgme_key_t *encryptkeys;
unsigned int encrypt_size;
HashTable *signkeys;
HashTable *decryptkeys;
} gnupg_object;
zend_class_entry *gnupg_class_entry;
PHP_MINIT_FUNCTION(gnupg);
PHP_MSHUTDOWN_FUNCTION(gnupg);
PHP_MINFO_FUNCTION(gnupg);
PHP_FUNCTION(gnupg_keyinfo);
PHP_FUNCTION(gnupg_verify);
PHP_FUNCTION(gnupg_geterror);
PHP_FUNCTION(gnupg_setsignmode);
PHP_FUNCTION(gnupg_setarmor);
PHP_FUNCTION(gnupg_sign);
PHP_FUNCTION(gnupg_clearsignkeys);
PHP_FUNCTION(gnupg_clearencryptkeys);
PHP_FUNCTION(gnupg_cleardecryptkeys);
PHP_FUNCTION(gnupg_getprotocol);
PHP_FUNCTION(gnupg_encrypt);
PHP_FUNCTION(gnupg_encryptsign);
PHP_FUNCTION(gnupg_decrypt);
PHP_FUNCTION(gnupg_decryptverify);
PHP_FUNCTION(gnupg_export);
PHP_FUNCTION(gnupg_import);
PHP_FUNCTION(gnupg_init);
PHP_FUNCTION(gnupg_addsignkey);
PHP_FUNCTION(gnupg_addencryptkey);
PHP_FUNCTION(gnupg_adddecryptkey);
PHP_FUNCTION(gnupg_deletekey);
PHP_FUNCTION(gnupg_gettrustlist);
PHP_FUNCTION(gnupg_listsignatures);
PHP_FUNCTION(gnupg_seterrormode);
#ifdef ZTS
#define GNUPG_G(v) TSRMG(gnupg_globals_id, zend_gnupg_globals *, v)
#else
#define GNUPG_G(v) (gnupg_globals.v)
#endif
#endif /* PHP_GNUPG_H */
/*
* Local variables:
* tab-width: 4
* c-basic-offset: 4
* End:
* vim600: noet sw=4 ts=4 fdm=marker
* vim<600: noet sw=4 ts=4
*/
gnupg-1.3.3/php_gnupg_keylistiterator.h 0000644 0000765 0000024 00000003761 12171502055 015237 0 ustar /*
+--------------------------------------------------------------------+
| PECL :: gnupg |
+--------------------------------------------------------------------+
| Redistribution and use in source and binary forms, with or without |
| modification, are permitted provided that the conditions mentioned |
| in the accompanying LICENSE file are met. |
+--------------------------------------------------------------------+
| Copyright (c) 2006, Thilo Raufeisen |
| Copyright (c) 2013, Jim Jagielski |
+--------------------------------------------------------------------+
*/
/* $Id: php_gnupg_keylistiterator.h 330795 2013-07-08 14:11:30Z jimjag $ */
#ifndef PHP_GNUPG_KEYLISTITERATOR_H
#define PHP_GNUPG_KEYLISTITERATOR_H
extern zend_module_entry gnupg_keyiterator_module_entry;
#ifdef PHP_WIN32
#define PHP_GNUPG_API __declspec(dllexport)
#else
#define PHP_GNUPG_API
#endif
#ifdef ZTS
#include "TSRM.h"
#endif
#include
#define gnupg_keylistiterator_init() _gnupg_keylistiterator_init(INIT_FUNC_ARGS_PASSTHRU)
extern int _gnupg_keylistiterator_init(INIT_FUNC_ARGS);
typedef struct _gnupg_keylistiterator_object{
zend_object zo;
gpgme_ctx_t ctx;
gpgme_error_t err;
gpgme_key_t gpgkey;
zval pattern;
} gnupg_keylistiterator_object;
zend_class_entry *gnupg_keylistiterator_class_entry;
PHP_METHOD(gnupg_keylistiterator, __construct);
PHP_METHOD(gnupg_keylistiterator, current);
PHP_METHOD(gnupg_keylistiterator, next);
PHP_METHOD(gnupg_keylistiterator, rewind);
PHP_METHOD(gnupg_keylistiterator, key);
PHP_METHOD(gnupg_keylistiterator, valid);
#ifdef ZTS
#define GNUPG_G(v) TSRMG(gnupg_globals_id, zend_gnupg_globals *, v)
#else
#define GNUPG_G(v) (gnupg_globals.v)
#endif
#endif /* PHP_GNUPG_H */
/*
* Local variables:
* tab-width: 4
* c-basic-offset: 4
* End:
* vim600: noet sw=4 ts=4 fdm=marker
* vim<600: noet sw=4 ts=4
*/
gnupg-1.3.3/README 0000644 0000765 0000024 00000000321 12171502055 010426 0 ustar A documentation how to install a PECL-Extension is available in the PHP-Manual http://www.php.net/manual/en/install.pecl.php
The documentation is now available in the PHP-Manual http://www.php.net/manual/en/