Az alábbi dokumentáció az xsign.dll aláíró modul leírása fejlesztők részére. Ezen dokumentumnak nem tartalma:
Azok az információk, melyek a header fájlokból egyértelműen kiderülnek, nem kerülnek bele ebbe a dokumentációba. Ilyen információnak tekinthetők a típusdefiníciók, bizonyos függvényparaméterek.
Az interfészen az összes be- és kimeneti string (XS_CHAR_PTR) kódolása UTF-8.
A modul használatához szükségesek a következő modulok:
Az MFC és C runtime dll-ek a http://www.microsoft.com/en-us/download/details.aspx?id=40784 csomag telepítésével is beszerezhetők.
Tudnivalók:
A XadesSignerLocale_*.* elnevezésű fájlok az általuk megjelölt nyelvet támogatják. Amennyiben az adott nyelvre nincsen szükség, a hozzá tartozó modulok elhagyhatóak.
A fejlesztői modul használható regisztráció nélkül. (A szoftver nem ingyenes ebben az esetben sem, pontos árakért és licenc információkért keresse a Microsec zrt-t) Ebben az esetben minden funkcionalitás elérhető és teljes értékű, amennyiben Microsec e-Szignó hitelesítés szolgáltató által kiadott tanúsítványokkal használják. Más hitelesítés szolgáltató által kiadott tanúsítványokkal nem működik teljes körűen a fejlesztőeszköz.
Amennyiben a regisztráció megtörténik, akkor a fejlesztőeszköz teljes értékű és teljes funkcionalitású lesz.
A regisztrációhoz egy regisztrációs fájlra van szükség, amit a modul inicializálásakor kell megadni. A regisztrációs fájlt a Microsec zrt. munkatársai tudják kiállítani a licence megvásárlása után vagy a modul képes előállítani egy regisztrációs kulcs megadásával.
Több szálú használat esetén a XS_SetOption() XSO_LOG_FILE_PATH, XSO_LOG_FILE_PATH_EX, XSO_DEBUG_CALLBACK és XSO_DEBUG_CALLBACK_EX használatával szálankénti naplózást lehet beállítani.
Abban az esetben, ha egy szál nem állít be naplózást, akkor a fő szál naplózási beállításait használja. A XSO_SESSION_FORKINSTANCE XS_SetOption() paraméter a szülő szál naplózási beállításait csak akkor másolja, ha a gyermek szálban még nincs beállított naplózás.
Minden szál ami állít naplózást, a megnyitott naplófájl felszabadításához illetve callback referencia törléséhez NULL pValue pareméterrel kell meghívnia naplózási beállítást. XSO_SESSION_FORKINSTANCE használata esetén a XSO_SESSION_RELEASEINSTANCE hívás elvégzi ezt a felszabadítást.
Ha több szál ugyanazt a naplófájlt vagy callback-ot állítja be, akkor a naplózás szálbiztos.
Egy naplófájlhoz vagy callbackhez -még ha több szál külön állítja is be- csak egy naplózási szint tartozhat.
Ez a függvény az xsign belépési pontja.
Ennek segítségével lehet lekérni az aláíró funkcionalitást megvalósító függvényhalmazt.
Az xsign-t használat előtt inicializálni kell ezen függvény segítségével. A bemeneti paraméterben megadott könyvtárba ideiglenes fájlokat fog elhelyezni a program, ezért oda írási jogosultságának kell lennie.
typedef struct initialize_struct
{
XS_ULONG structSize;
XS_CHAR_PTR pWorkDir;
XS_CHAR_PTR pRegFile;
XS_CHAR_PTR pSDKPassword;
} XS_INITIALIZE_DATA, XS_PTR XS_INITIALIZE_DATA_PTR;
A futás végeztével meg kell hívni a XS_Finalize() függvényt, hogy a lefoglalt memóriaterületeket felszabadítsa. Az XS_Finalize() hatására érvénytelenné válnak a korábban használt XS_HANDLE típusú változók.
pData – mindig NULL értékű.
Új e-aktát hoz létre. A korábban létrehozott e-aktákat nem érinti az új dokumentum létrehozása; azaz több e-aktán is lehet párhuzamosan dolgozni. A dokumentumhoz tartozó környezet is inicializálódik a függvény meghívásával, így például külön URL cache jön léte minden új dokumentumhoz.
Bemeneti paraméter, értéke lehet NULL.
typedef struct new_dossier_struct
{
XS_ULONG structSize;
XS_BOOL dontCreateFrame;
} XS_NEW_DOSSIER_DATA, XS_PTR XS_NEW_DOSSIER_DATA_PTR;
Kimeneti paraméter, értéke nem lehet NULL. Amennyiben a végrehajtás sikeres, az érték az új e-aktára hivatkozó HANDLE.
Felszabadítja a már létrehozott e-aktát és a hozzá tartozó környezeti változókat.
Értéke NULL.
Bemeneti paraméter, értéke nem lehet NULL. Handle a felszabadítani kívánt e-aktára. Sikeres felszabadítás után a handle értéke NULL-ra állítódik.
Elmenti az e-aktát.
Az elmenteni kívánt e-aktára hivatkozó HANDLE. Bemeneti paraméter.
Ez a struktúra adja meg a mentés paramétereit.
typedef struct save_dossier_struct
{
XS_ULONG structSize;
XS_CHAR_PTR pFilePath;
XS_BUFFER_PTR pBuffer;
} XS_SAVE_DOSSIER_DATA, XS_PTR XS_SAVE_DOSSIER_DATA_PTR;
A fájlrendszerből, vagy átadott memórián keresztül megnyit egy e-aktát
Bemeneti paraméter. Ez a struktúra határozza meg az e-akta megnyitásának körülményeit.
typedef struct open_dossier_struct
{
XS_ULONG structSize;
XS_CHAR_PTR pFilePath;
XS_BUFFER_PTR pBuffer;
XS_BOOL passAllXMLs;
} XS_OPEN_DOSSIER_DATA, XS_PTR XS_OPEN_DOSSIER_DATA_PTR;
typedef struct buffer_struct
{
XS_BYTE_PTR pBuffer;
XS_ULONG bufferLength;
} XS_BUFFER, XS_PTR XS_BUFFER_PTR;
Amennyiben a pFilePath változó értéke nem NULL, ez az érték figyelmen kívül marad.
Kimeneti paraméter. A megnyitott e-aktára hivatkozó HANDLE –t kapja meg a változó, ha a megnyitás sikeresen megtörtént. Használat után az XS_FreeDossier() nevű függvénnyel fel kell szabadítani a lefoglalt memóriaterületet.
Létező e-aktába dokumentumot illeszt be. A dokumentum címe a beillesztett fájl neve lesz. A dokumentum címe később megváltoztatható. Windows operációs rendszeren az alkalmazás automatikusan felismeri a fájl MIME típusát, ha az be van regisztrálva a Windowsba.
Linux operációs rendszeren eltérően működik a Windowsos viselkedésétől.
Bemeneti paraméter. Ezzel a dokumentum mutató segítségével lehet megadni, hogy melyik e-aktába kerüljön beillesztésre a további paraméterekben megadott dokumentum.
Bemeneti paraméter. A beillesztendő dokumentum elérési útját tartalmazza.
typedef struct insert_document_struct
{
XS_ULONG structSize;
XS_CHAR_PTR pFilePath;
XS_BUFFER_PTR pBuffer;
XS_CHAR_PTR pMIMEType;
XS_CHAR_PTR pExtension;
XS_BOOL dontCompress;
} XS_INSERT_DOCUMENT_DATA, XS_PTR XS_INSERT_DOCUMENT_DATA_PTR;
Kimeneti paraméter. A beillesztett dokumentumra hivatkozó HANDLE-re mutató pointer. Ezzel lehet később műveleteket végezni a dokumentumon.
Megnyitott e-aktából lehet exportálni dokumentumokat. Kimásolja a beillesztett fájlt a fájlrendszerbe, vagy egy megadott memóriaterületre.
Bemeneti paraméter. Az exportálandó dokumentumra hivatkozó HANDLE.
Bemeneti paraméter. A dokumentum exportálására vonatkozó adatokat tartalmaz.
typedef struct export_document_struct
{
XS_ULONG structSize;
XS_CHAR_PTR pFilePath;
XS_BUFFER_PTR pBuffer;
XS_BOOL dontDecrypt;
} XS_EXPORT_DOCUMENT_DATA, XS_PTR XS_EXPORT_DOCUMENT_DATA_PTR;
Ha a dokumentum nem volt titkosítva, akkor a dontDecrypt paraméter értékének nincs hatása.
Ha a dokumentum titkosítva volt, akkor a dontDecrypt paraméter XS_TRUE értéke esetén a titkosított dokumentumot PKCS7 formátumban BASE64 kódolva kapjuk.
Egy e-aktában található dokumentumot ír alá a függvény. Az aláírás folyamata és az elkészülő aláírás nagymértékben függ a korábban beállított környezeti paraméterektől.
A beállítható paraméterek leírását lásd az XS_SetOption() függvény leírásánál.
Bemeneti paraméter. Az aláírni kívánt dokumentumra hivatkozó HANDLE.
Az aláírás tulajdonságait adhatjuk meg a struktúra segítségével. Bemeneti paraméter. A struktúra egyetlen eleme sem kötelező, kivéve a structSize.
typedef struct sign_properties_struct
{
XS_ULONG structSize;
XS_CHAR_PTR pSignaturePolicy;
XS_CHAR_PTR pSigPlacePostalCode;
XS_CHAR_PTR pSigPlaceSettlement;
XS_CHAR_PTR pSigPlaceProvince;
XS_CHAR_PTR pSigPlaceCountry;
XS_CHAR_PTR pSignerRole;
XS_CHAR_PTR pCommitmentType;
XS_ULONG commentType;
XS_INSERT_DOCUMENT_DATA_PTR pCommentDoc;
} XS_SIGN_PROPERTIES, XS_PTR XS_SIGN_PROPERTIES_PTR;
Kimeneti paraméter. Helyes működés esetén a megadott címre másolja az aláírásra hivatkozó HANDLE-t.
A függvény több dokumentumot aláír egy e-aktán belül. Az aláírás folyamata és az elkészülő aláírás nagymértékben függ a korábban beállított környezeti paraméterektől.
A beállítható paraméterek leírását lásd az XS_SetOption() függvény leírásánál.
Az aláírandó fájlokat és az aláírás paramétereit adhatjuk meg a struktúra segítségével. Bemeneti paraméter.
typedef struct sign_documents_data_struct
{
XS_ULONG structSize;
XS_HANDLE_ARRAY_PTR pDocsHandles;
XS_SIGN_PROPERTIES_PTR pSignProperties;
} XS_SIGN_DOCUMENTS_DATA, XS_PTR XS_SIGN_DOCUMENTS_DATA_PTR;
Egy e-aktában található dokumentumot és a rajta lévő összes aláírást írja alá a függvény. Az aláírás folyamata és az elkészülő ellenjegyzés nagymértékben függ a korábban beállított környezeti paraméterektől.
A beállítható paraméterek leírását lásd az XS_SetOption() függvény leírásánál.
Bemeneti paraméter. Az aláírni kívánt dokumentumra hivatkozó HANDLE.
Későbbi felhasználásra fenntartva. Értéke NULL.
Kimeneti paraméter. Helyes működés esetén a megadott címre másolja az aláírásra hivatkozó HANDLE-t.
Különálló aláírást készít. Az aláírás folyamata és az elkészülő aláírás nagymértékben függ a korábban beállított környezeti paraméterektől.
A beállítható paraméterek leírását lásd az XS_SetOption() függvény leírásánál.
typedef struct sign_files_struct
{
XS_ULONG structSize;
XS_DOSSIER_HANDLE dossierHandle;
XS_CHAR_PTR pURLList;
XS_CHAR_PTR pMimeTypeList;
XS_SIGN_PROPERTIES_PTR pSignProperties;
} XS_SIGN_FILES_DATA, XS_PTR XS_SIGN_FILES_DATA_PTR;
Egy keretaláírást hoz létre az e-aktában. Az akta aláírása egyben aláírja az aktában lévő összes dokumentumot. Ez azt jelenti, hogy az e-akta tartalma nem módosítható, nem illeszthetünk be újabb dokumentumokat és nem készíthetünk újabb aláírást a dokumentumokra. Ezzel szemben az aktára további keretaláírások helyezhetők el. Az aláírás folyamata és az elkészülő aláírás nagymértékben függ a korábban beállított környezeti paraméterektől.
A beállítható paraméterek leírását lásd az XS_SetOption() függvény leírásánál.
Bemeneti paraméter. Az aláírni kívánt e-aktára hivatkozó HANDLE –t kell megadni.
Az aláírás tulajdonságait adhatjuk meg a struktúra segítségével. Bemeneti paraméter. Paraméter részletes leírása az XS_SignDocument függvénynél található.
Kimeneti paraméter. Sikeres működés esetén a pointer által hivatkozott címre kerül a keretaláírásra hivatkozó HANDLE.
Egy ellenjegyzést készít az e-aktában. Az akta aláírása egyben aláírja az aktában lévő összes dokumentumot, aláírást és a többi keretaláírást is. Ez azt jelenti, hogy az e-akta tartalma nem módosítható, nem illeszthetünk be újabb dokumentumokat és nem készíthetünk újabb aláírást a dokumentumokra. Ezzel szemben az aktára további keretaláírások helyezhetők el. Az aláírás folyamata és az elkészülő aláírás nagymértékben függ a korábban beállított környezeti paraméterektől.
A beállítható paraméterek leírását lásd az XS_SetOption() függvény leírásánál.
Bemeneti paraméter. Az aláírni kívánt e-aktára hivatkozó HANDLE–t kell megadni.
Bemeneti paraméter. Az aláíráshoz szükséges paramétereket tartalmazó struktúrára mutató pointer. Későbbi felhasználásra fenntartva, értéke NULL.
Kimeneti paraméter. Sikeres működés esetén a pointer által hivatkozott címre kerül a keretaláírásra hivatkozó HANDLE.
Időbélyeget készít a megadott dokumentumra. Az időbélyeg szolgáltató az XS_SetOption függvény segítségével állítható be, ennek a leírása az XS_SetOption() függvény leírásánál található.
Bemeneti paraméter. Az időbélyegezni kívánt dokumentumra hivatkozó HANDLE –t kell megadni.
Bemeneti paraméter. A dokumentum időbélyegzéséhez szükséges paramétereket tartalmazó struktúrára mutató pointer. Későbbi felhasználásra fenntartva, értéke NULL.
Kimeneti paraméter. Sikeres működés esetén a pointer által hivatkozott címre kerül a dokumentum időbélyegére hivatkozó HANDLE.
Időbélyeget készít az e-aktára. Az akta időbélyege egyben aláírja az aktában lévő összes dokumentumot. Ez azt jelenti, hogy az e-akta tartalma nem módosítható, nem illeszthetünk be újabb dokumentumokat és nem készíthetünk újabb aláírást a dokumentumokra. Ezzel szemben az aktára további aláírások, időbélyegek helyezhetők el. Az időbélyeg szolgáltató az XS_SetOption() függvény segítségével állítható be.
Bemeneti paraméter. Az időbélyegezni kívánt e-aktára hivatkozó HANDLE –t kell megadni.
Bemeneti paraméter. Az e-akta időbélyegzéséhez szükséges paramétereket tartalmazó struktúrára mutató pointer. Későbbi felhasználásra fenntartva, értéke NULL.
Kimeneti paraméter. Sikeres működés esetén a pointer által hivatkozott címre kerül az e-akta időbélyegére hivatkozó HANDLE.
Dokumentumon, vagy e-aktán lévő aláírást illetve időbélyeget ellenőriz. Az aláírást a beállított XS_SetOption() függvény által beállított XAdES típus alapján próbálja validálni. Ha magasabb XAdES típus van beállítva ellenőrzéskor, mint az ellenőrizendő aláírásé, akkor a folyamat kiegészíti az aláírást a megfelelő kellékekkel, hogy megfeleljen a beállításoknak.
Bemeneti paraméter. Az ellenőrizendő aláírás, vagy időbélyegre hivatkozó HANDLE.
Bemeneti paraméter. Az aláírás vagy időbélyeg ellenőrzéséhez szükséges paramétereket tartalmazó struktúrára mutató pointer. Későbbi felhasználásra fenntartva, értéke NULL.
Az optionId paraméterben megadott beállításnak a pValue értéket állítja be. A típusa függ a beállítandó paramétertől. A beállítások rendszerint (szálanként) globális, a többi függvény működésére is kihatással levő változásokat eredményeznek.
Bemeneti paraméter mind a kettő. Az optionId beállítani kívánt paramétert adja meg. Az optionId által meghatározott paraméter egyedi pValue értékeket követel meg. Az alábbiakban találhatóak az érvényes optionId / pValue párosok.
Az optionId paraméter a következő értékeket veheti föl:
Az aláíráshoz és aláírás ellenőrzéshez használt XAdES típust lehet beállítani. Ekkor a pValue a következő értékeket veheti föl:
Ha ETSI EN 319 * szabványok alapján szeretne aláírást készíteni, akkor használja az XSO_SIGNATURE_LEVEL kapcsolót.
Az aláíráshoz és aláírás ellenőrzéshez használt AdES baseline/extended profilt lehet vele beállítani. A pValue értékei a következőek lehetnek:
Megjegyzés: Az XSO_SIGNATURE_LEVEL és a XSO_XADES_TYPE opciók csak egymástól függetlenül használhatóak, egyszerre megadva a két paramétert az xsign hibát fog jelezni.
A visszavonás-ellenőrzés módját lehet beállítani. A beállított érték vonatkozik az aláíráskori és az ellenőrzéskori visszavonás-ellenőrzésre is. Amennyiben az ellenőrizendő aláírás már tartalmaz magában csatolt visszavonási információkat, akkor az alkalmazás azok alapján ellenőriz, ha az egyezik a beállított visszavonási móddal. Azaz, ha például az archív aláírás OCSP válaszokat tartalmaz magában, és a visszavonás ellenőrzés is OCSP-re van állítva, akkor a tárolt válasz alapján ellenőriz az alkalmazás. Az archív aláírás ellenőrzése függetlenül ettől a beállítástól kikapcsolható. Ekkor a pValue a következő értékeket veheti föl:
A paraméter az időbélyeg szolgáltatók URL listáját állítja be. Időbélyeges aláírás és különálló időbélyeg készítésekor is ebből a listából választ az alkalmazás, hogy melyik szolgáltatóhoz forduljon időbélyegért. A lista első elemével próbálkozik először, amennyiben ez nem sikerül megpróbál a következő helyről időbélyeget kérni, és így tovább. A pValue paraméterben, szóközzel elválasztott karakterlánc formájában kell a listát megadni.
A felhasználandó CRL szolgáltatók listáját lehet megadni ezen opció segítségével. Általában akkor van szükség e beállításra, ha az ellenőrizendő tanúsítványok nem tartalmazzák a rájuk érvényes CRL szolgáltató URL-jét az AIA kiterjesztésben. A pValue paraméterben, szóközzel elválasztott karakterlánc formájában kell a listát megadni.
Megjegyzés: WINCE operációs rendszeren nem támogatott ez az opció.
A felhasználandó OCSP szolgáltatók listáját lehet megadni ezen opció segítségével. Általában akkor van szükség e beállításra, ha az ellenőrizendő tanúsítványok nem tartalmazzák a rájuk érvényes OCSP szolgáltató URL-jét az AIA kiterjesztésben. A pValue paraméterben, szóközzel elválasztott karakterlánc formájában kell a listát megadni.
Megjegyzés: WINCE operációs rendszeren nem támogatott ez az opció.
Megjegyzés: ez az opció csak Windows operációs rendszereken támogatott.
Bizonyos esetekben az alkalmazás dialógus ablakok segítségével akar kommunikálni a felhasználóval. Ezen opció segítségével a megjelenő ablakok szülőablakát adhatjuk meg. Ebben az esetben a paraméter típusa egy HWND kell, hogy legyen.
Az alkalmazás működése során státusz üzeneteket ad arról, hogy miként folyik a feldolgozás. Az XSO_STATUS_CALLBACK segítségével megadhatunk egy függvényt, amely feldolgozza (megjeleníti a felhasználó számára) az üzeneteket. A pValue értéke a feldolgozó függvényre mutató pointer kell, hogy legyen, ahol a függvény típusa:
typedef XS_CALLBACK_FUNCTION(XS_RV, XS_STATUSCALLBACK)(XS_CHAR_PTR pMessage);
A pMessage paraméter kapja meg a státusz üzenetet.
Figyelem! Az üzenetek feldolgozását végző függvény nem hívhat meg XSign függvényt, mert az azokban elhelyezett zárak miatt blokkolódás alakulhat ki.
Amennyiben nem XSR_OK-val tér vissza a függvény, a feldolgozási folyamat megszakad.
Megjegyzés: ez az opció csak Windows operációs rendszereken támogatott.
Ez a beállítás befolyásolja a működés közben a felhasználóval való kommunikációt és a megjelenő üzeneteket. Ha a pValue paraméter értéke:
Megjegyzés: ez az opció WinCE operációs rendszeren nem támogatott.
Amennyiben adott URL-ről tölt le valamit az alkalmazás, akkor előtte a saját cache-ben keresi és ha ott megtalálta, akkor nem fordul az adott URL-hez. A cache az e-aktához tartozik, azaz ha új e-aktát hozunk létre pl. az XS_NewDossier() függvénnyel, akkor a cache is ürül. Ezen beállítás segítségével rendelhetünk egy URL-hez egy dokumentumot.
pValue értéke a következő struktúra
typedef struct add_to_url_cache_struct {
XS_ULONG structSize;
XS_DOSSIER_HANDLE dossierHandle;
XS_CHAR_PTR pURL;
XS_BUFFER buffer;
} XS_ADD_TO_URL_CACHE_DATA, XS_PTR XS_ADD_TO_URL_CACHE_DATA_PTR;
Ezen paraméter segítségével beállíthatunk egy alapértelmezett aláírói tanúsítványt. Ha ez megtörtént, akkor aláírás kezdetekor az alkalmazás nem kéri, hogy válasszunk aláírói tanúsítványt. A pValue típusa PCERT_CONTEXT.
Ez az opció csak Windows operációs rendszereken támogatott.
A naplófájl helyét állítja be. A pValue értékeként kell megadni a fájlnevet teljes elérési úttal, ekkor a megadott fájlt megnyitja és a végéhez illeszti a tartalmat. A naplózási szintent automatikusan XS_LOG_LEVEL_DEBUG (4)-ra állítja. Amennyiben pValue értéke NULL, lezárja a már megnyitott naplófájlt.
Ezen opció segítségével beállíthatjuk, hogy futás közben keletkezzen-e naplófájl. A naplózás módját a pValue értékével állíthatjuk. pValue típusa:
typedef struct log_file_path_ex_struct {
XS_ULONG structSize;
XS_ULONG logLevel;
XS_CHAR_PTR logFilePath;
XS_ULONG maxSizeOfLogFile;
} XS_LOG_FILE_PATH_EX_DATA, XS_PTR XS_LOG_FILE_PATH_EX_DATA_PTR;
Amennyiben pValue vagy a logFilePath értéke NULL, lezárja a már megnyitott naplófájlt.
Ezen opció segítségével egy callback függvényt adhatunk meg, mely a debug üzenetek feldolgozását végzi. A pValue értéke egy XS_STATUS_CALLBACK típusú függvény kell, hogy legyen. A naplózási szintent automatikusan XS_LOG_LEVEL_DEBUG (4)-ra állítja. Amennyiben pValue értéke NULL, törli a callback referenciát.
Ezen opció segítségével egy callback függvényt adhatunk meg, mely a debug üzenetek feldolgozását végzi A naplózás módját a pValue értékével állíthatjuk. pValue típusa:
typedef struct debug_callback_ex_struct {
XS_ULONG structSize;
XS_ULONG debugLevel;
XS_DEBUGCALLBACK debugCallback;
} XS_DEBUG_CALLBACK_EX_DATA, XS_PTR XS_DEBUG_CALLBACK_EX_DATA_PTR;
Időbélyeg szolgáltatóhoz való tanúsítvány alapú bejelentkezéshez tartozó tanúsítványt állíthatjuk be a pValue paraméter értékeként. pValue típusa PCERT_CONTEXT.
Ez az opció csak Windows operációs rendszereken támogatott.
OCSP szolgáltatóhoz való tanúsítvány alapú bejelentkezéshez tartozó tanúsítványt állíthatjuk be a pValue paraméter értékeként. pValue típusa PCERT_CONTEXT.
Ez az opció csak Windows operációs rendszereken támogatott.
Az opció segítségével beállítható az alapértelmezett titkosító tanúsítvány. A tanúsítványt pValue paraméterben adhatjuk meg, típusa PCERT_CONTEXT.
Ez az opció csak Windows operációs rendszereken támogatott.
Az e-szigno.hu domainhez, így időbélyeg szolgáltatóhoz és OCSP szolgáltatóhoz tartozó login név/jelszó alapú bejelentkezéshez tartozó login nevet és jelszót állíthatjuk be. pValue típusa:
Ez az opció csak Windows operációs rendszereken támogatott.
typedef struct basic_auth_struct {
XS_ULONG structSize;
XS_CHAR_PTR pLogin;
XS_CHAR_PTR pPassword;
} XS_BASIC_AUTH_DATA, XS_PTR XS_BASIC_AUTH_DATA_PTR;
Az aláíráshoz használni kívánt tanúsítványt állíthatjuk be a pValue értékeként. pValue típusa:
typedef struct signing_certificate_struct
{
XS_ULONG structSize;
XS_KEY_TYPE keyType;
XS_VOID_PTR pData;
} XS_SIGNING_CERTIFICATE_DATA, XS_PTR XS_SIGNING_CERTIFICATE_DATA_PTR;
keyType Lehetséges értékei:
PFX fájl. Ebben az esetben pData XS_PFX_KEY_DATA_PTR típusú kell legyen, melynek a következő a definíciója:
typedef struct pfx_key_struct
{
XS_ULONG structSize;
XS_CHAR_PTR pPath;
XS_CHAR_PTR pPassword;
} XS_PFX_KEY_DATA, XS_PTR XS_PFX_KEY_DATA_PTR;
Tanúsítvány fájl. Ebben az esetben pData XS_CERT_KEY_DATA_PTR típusú kell legyen, melyek a következő a definíciója:
typedef struct cert_key_struct
{
XS_ULONG structSize;
XS_CHAR_PTR pPath;
} XS_CERT_KEY_DATA, XS_PTR XS_CERT_KEY_DATA_PTR;
PEM formátumú kulcs és tanúsítvány fájl. Ebben az esetben a pData XS_PEM_KEY_DATA típusú kell legyen.
typedef struct pem_key_struct {
XS_ULONG structSize;
XS_CHAR_PTR pKeyPath;
XS_CHAR_PTR pKeyPassword;
XS_CHAR_PTR pCertPath;
} XS_PEM_KEY_DATA, XS_PTR XS_PEM_KEY_DATA_PTR;
PKCS#11-es dinamikusan betölthető függvénykönyvtár segítségével nyerjük ki az aláíró tanúsítványt és kulcsot. Ebben az esetben a pData XS_PKCS11_KEY_DATA típusú kell legyen.
typedef struct pkcs11_key_struct {
XS_ULONG structSize;
XS_CHAR_PTR pPKCS11ModulePath;
XS_CHAR_PTR keyRef;
XS_ULONG keyRefType;
XS_CHAR_PTR pKeyPassword;
XS_CHAR_PTR pUserPIN;
XS_CHAR_PTR pContextSpecificPIN;
} XS_PKCS11_KEY_DATA, XS_PTR XS_PKCS11_KEY_DATA_PTR;
Példa :
XS_SIGNING_CERTIFICATE_DATA scd; XS_PFX_KEY_DATA pfxd; pfxd.structSize = sizeof(pfxd); pfxd.pPath = "test_files/keys/peterke.pfx"; pfxd.pPassword = "12345"; scd.structSize = sizeof(scd); scd.keyType = XS_KEYFORM_PFX; scd.pData = &pfxd; XS_SetOption(XSO_SIGNING_CERTIFICATE, &scd);
pValue XS_FALSE értéke esetén a modul nem használja a Windows tanúsítványtárát. Alapértelmezett értéke XS_TRUE. Csak Windows operációs rendszereken értelmezett.
Megjegyzés: ez az opció WinCE operációs rendszeren nem támogatott.
A megbízható gyökér hitelesítés szolgáltatók tanúsítványait tartalmazó könyvtárakat adhatjuk meg a paraméter segítségével. A pValue értéke a könyvtárak pontosvesszővel elválasztott elérési útjait tartalmazó string. Ennek a paraméternek csak akkor van értelme, ha a modul nem a Windows tanúsítványtárát használja, azaz XSO_WIN_USE_CERT_STORE == XS_FALSE
A korábbi beállításokat felülírja, akkor is, ha azokat a következő OptionId-k valameyikével állítottuk be: XSO_SIGNER_TRUSTED_CERT_DIR, XSO_TSA_TRUSTED_CERT_DIR, XSO_OCSP_TRUSTED_CERT_DIR
Megjegyzés: ez az opció WinCE operációs rendszeren nem támogatott.
Az aláíás ellenőrzéskor használt megbízható gyökér hitelesítés szolgáltatók tanúsítványait tartalmazó könyvtárakat adhatjuk meg a paraméter segítségével. A pValue értéke a könyvtárak pontosvesszővel elválasztott elérési útjait tartalmazó string. Ennek a paraméternek csak akkor van értelme, ha a modul nem a Windows tanúsítványtárát használja, azaz XSO_WIN_USE_CERT_STORE == XS_FALSE
A korábbi beállításokat felülírja.
Megjegyzés: ez az opció WinCE operációs rendszeren nem támogatott.
Az időbélyeg válaszok aláírásinak ellenőrzésekor használt megbízható gyökér hitelesítés szolgáltatók tanúsítványait tartalmazó könyvtárakat adhatjuk meg a paraméter segítségével. A pValue értéke a könyvtárak pontosvesszővel elválasztott elérési útjait tartalmazó string. Ennek a paraméternek csak akkor van értelme, ha a modul nem a Windows tanúsítványtárát használja, azaz XSO_WIN_USE_CERT_STORE == XS_FALSE
A korábbi beállításokat felülírja.Megjegyzés: ez az opció WinCE operációs rendszeren nem támogatott.
Az OCSP válaszok aláírásinak ellenőrzésekor használt a megbízható gyökér hitelesítés szolgáltatók tanúsítványait tartalmazó könyvtárakat adhatjuk meg a paraméter segítségével. A pValue értéke a könyvtárak pontosvesszővel elválasztott elérési útjait tartalmazó string. Ennek a paraméternek csak akkor van értelme, ha a modul nem a Windows tanúsítványtárát használja, azaz XSO_WIN_USE_CERT_STORE == XS_FALSE
A korábbi beállításokat felülírja.
Megjegyzés: ez az opció WinCE operációs rendszeren nem támogatott.
Megadhatjuk azoknak a könyvtáraknak az elérési útjait, amelyekben azok a tanúsítványok találhatóak, amelyeket a webserverek tanúsítványainak ellenőrzésekor megbízható tanúsítványnak fogadunk el. A pValue értéke a könyvtárak pontosvesszővel elválasztott elérési útjait tartalmazó string. Ennek a paraméternek csak akkor van értelme, ha a modul nem a Windows tanúsítványtárát használja, azaz XSO_WIN_USE_CERT_STORE == XS_FALSE
A korábbi beállításokat felülírja.
Megjegyzés: ez az opció WinCE operációs rendszeren nem támogatott.
A közbenső szintű tanúsítványokat tartalmazó könyvtárakat adhatjuk meg a paraméter segítségével. pValue értéke a könyvtárak pontosvesszővel elválasztott elérési útjait tartalmazó string. Ennek a paraméternek csak akkor van értelme, ha a modul nem a Windows tanúsítványtárát használja, azaz XSO_WIN_USE_CERT_STORE == XS_FALSE
Megjegyzés: ez az opció WinCE operációs rendszeren nem támogatott.
Adott szerverekhez tartozó tanúsítvány alapú autentikációhoz tartozó információkat adhatunk meg egy listában. pValue értéke tartalmazza az autentikációs listát. Típusa:
typedef struct cert_auth_struct {
XS_ULONG hostCount;
XS_HOST_CERT_AUTH_DATA_PTR pHostData;
} XS_CERT_AUTH_DATA, XS_PTR XS_CERT_AUTH_DATA_PTR;
typedef struct host_cert_auth_struct {
XS_CHAR_PTR pHostName;
XS_CHAR_PTR pPFXPath;
XS_CHAR_PTR pPFXPassword;
} XS_HOST_CERT_AUTH_DATA, XS_PTR XS_HOST_CERT_AUTH_DATA_PTR;
XS_HOST_CERT_AUTH_DATA hcad[1] = { 0 };
XS_CERT_AUTH_DATA cad;
memset(&cad, 0, sizeof(cad));
hcad[0].pHostName = "teszt.e-szigno.hu";
hcad[0].pPFXPath = "test_files/keys/tauth.pfx";
cad.hostCount = 1;
cad.pHostData = hcad;
XS_SetOption(XSO_CERT_AUTH_LIST, &cad);
Megjegyzés: ez az opció WinCE operációs rendszeren nem támogatott.
Adott szerverekhez tartozó felhasználónév/jelszó alapú autentikációhoz tartozó információkat adhatunk meg egy listában. pValue értéke tartalmazza az autentikációs listát. Típusa:
typedef struct basic_auth_struct_2 {
XS_ULONG hostCount;
XS_HOST_BASIC_AUTH_DATA_PTR pHostData;
} XS_BASIC_AUTH_DATA_2, XS_PTR XS_BASIC_AUTH_DATA_2_PTR;
typedef struct host_basic_auth_struct {
XS_CHAR_PTR pHostName;
XS_CHAR_PTR pUserName;
XS_CHAR_PTR pPassword;
} XS_HOST_BASIC_AUTH_DATA, XS_PTR XS_HOST_BASIC_AUTH_DATA_PTR;
XS_HOST_BASIC_AUTH_DATA hbad[1] = { 0 };
XS_BASIC_AUTH_DATA_2 bad;
memset(&bad, 0, sizeof(bad));
hbad[0].pHostName = "btsa.e-szigno.hu";
hbad[0].pUserName = "felhasznalo";
hbad[0].pPassword = "jelszo";
bad.hostCount = 1;
bad.pHostData = hbad;
XS_SetOption(XSO_BASIC_AUTH_LIST, &bad);
Megjegyzés: ez az opció WinCE operációs rendszeren nem támogatott.
Ezen opció segítségével lehet beállítani, hogy az időbélyeg kérés, visszavonási információk lekérdezése és más internet hozzáférést megkövetelő műveletek milyen HTTP/1.1 proxy szerveren keresztül történjen.
pValue értékében kell megadni a proxy szerver elérhetőségeit, ennek típusa:
typedef struct proxy_settings_struct {
XS_ULONG structSize;
XS_CHAR_PTR pProxyAddress;
XS_ULONG proxyPort;
XS_BOOL bypassProxyForLocal;
XS_CHAR_PTR pUserName;
XS_CHAR_PTR pPassWord;
} XS_PROXY_SETTINGS_DATA, XS_PTR XS_PROXY_SETTINGS_DATA_PTR;
Megjegyzés: ez az opció WinCE operációs rendszeren nem támogatott.
Ezen opció segítségével lehet beállítani, hogy az időbélyeg kérés, visszavonási információk lekérdezése és más internet hozzáférést megkövetelő műveletek mennyi ideig próbálkozzanak a kapcsolat felépítésével. pValue értékében kell megadni a timeout nagyságát milliszekundumokban. LDAP kapcsolódás esetén fixen 15 másodperc a timeout függetlenül a beállított értéktől.
Ezen opció segítségével lehet beállítani, hogy bizonyos sikertelen HTTP kapcsolódások esetén (ha nem kap semmilyen választ, 503-as hiba, illetve TRYLATER OCSP válasz esetén) hányszor próbáljon meg újra csatlakozni. Alapértelmezett értéke 0.
Ha az XSO_CONNECTION_RETRY_COUNT be van állitva, akkor ezen opció segítségével lehet beállítani, hogy mennyi milliszekundumot várjon az újrapróbálkozások között. Alapértelmezett értéke 0.
Ha a pValue NULL, akkor a fő szál globális beállításaira hivatkozó handle-t adja vissza. Ha a pValue egy XS_SESSION_HANDLE típusú változóra mutat, akkor annak a szálnak a beállitásaira hivatkozó handle-t adja vissza.
Egy adott szál beállításait átmásolja az aktuális szál részére. Amennyiben pValue értéke NULL, a processz fő szálának beállításai kerülnek másolásra, egyéb esetben pValue egy, az XSO_SESSION_GETHANDLE opcióval lekért XS_SESSION_HANDLE típusú értékre mutat. Ilyenkor a handle által hivatkozott szál beállításai másolódnak át az aktuális szálhoz.
Ha a saját szálunk handle-jét adjuk meg akkor XSR_INVALID_OPERATION hibát kapunk.
Egy adott szál beállításainak felszabadítására használható ezen opció. Amennyiben pValue értéke NULL, az aktuális szál beállításai szabadulnak fel, egyébként pValue egy, az XSO_SESSION_GETHANDLE opcióval lekért XS_SESSION_HANDLE típusú értékre kell, hogy mutasson.
Ha a fő szálat próbáljuk felszabadítani, akkor XSR_INVALID_OPERATION hibát kapunk.
Ezen opció segítségével a státuszüzenetek callback függvényét állíthatjuk be, ahol a callback függvény a státuszüzeneten kívül egy kontextus pointert is paraméterül kap. pValue egy XS_STATUS_CALLBACK_EX_DATA típusú struktúrára mutat, melynek definíciója:
typedef struct status_callback_ex_struct {
XS_ULONG structSize;
XS_STATUSCALLBACK_EX pCallback;
XS_VOID_PTR pContext;
} XS_STATUS_CALLBACK_EX_DATA, XS_PTR XS_STATUS_CALLBACK_EX_DATA_PTR;
A callback függvény típusdefiníciója:
typedef XS_CALLBACK_FUNCTION(XS_RV, XS_STATUSCALLBACK_EX)( XS_CHAR_PTR pMessage, XS_VOID_PTR pContext );
Figyelem! Az üzenetek feldolgozását végző függvény nem hívhat meg XSign függvényt, mert az azokban elhelyezett zárak miatt blokkolódás alakulhat ki.
Amennyiben nem XSR_OK-val tér vissza a függvény, a feldolgozási folyamat megszakad.
Ezen opció segítségével beállíthatjuk, hogy a tanúsítványban található AIA URL-t használja-e a modul az OCSP szolgáltatás eléréséhez. Amennyiben pValue értéke XS_TRUE akkor a tanúsítványban található URL-t használja az alkalmazás. XS_FALSE érték esetén a korábban az XSO_OCSP_URL_LIST opció által beállított URLeket fogja használni a modul OCSP kéréshez.
Az XMLDSIG szabványnak megfelelő XML kanonizálások közül melyiket használja (c14n_incl, c14n_incl_wc, c14n_excl, c14n_excl_wc). Lehetséges értékek:
Az opció segítségével megadható az időbélyeg kérésben a hitelesítési rend OID. pValue értékéke az OID-t tartalmazó string.
Az opció segítségével megadható az időbélyeg kérésben, hogy a válasz tartalmazza-e az időbélyeg szerver tanúsítványát. pValue értékéke XS_TRUE/XS_FALSE lehet.
Az opció segítségével megadható, hogy az alkalmazás aláírás esetén megjelenítse-e az aláírni kíván dokumentumot. Ez a funkció csak windows operációs rendszereken érhető el. pValue értéke XS_TRUE/XS_FALSE lehet.
Az opció segítségével megadható, hogy a futás során keletkezett naplófájl tartalmazzon-e a hálózati kommunikációra vonatkozó információkat. pValue értékéke XS_TRUE/XS_FALSE lehet. Figyelem! Az XS_TRUE érték használata során megjelenhetnek autentikációs információk, jelszavak is a naplóban.
A titkosításhoz használni kívánt címzett tanúsítványokat állíthatjuk be, elérési útvonal alapján a pValue értékeként. pValue típusa:
typedef struct recipient_cert_struct
{
XS_ULONG certCount;
XS_CERT_KEY_DATA_PTR pCertData;
} XS_RECIPIENT_CERT_DATA, XS_PTR XS_RECIPIENT_CERT_DATA_PTR;
typedef struct cert_key_struct
{
XS_ULONG structSize;
XS_CHAR_PTR pPath;
} XS_CERT_KEY_DATA, XS_PTR XS_CERT_KEY_DATA_PTR;
Példa :
XS_CERT_KEY_DATA reciplist[1] = {0};
XS_RECIPIENT_CERT_DATA rec_data;
memset(&rec_data, 0, sizeof(rec_data));
reciplist[0].pPath = "certs/encrypting.cer";
reciplist[0].structSize = sizeof(reciplist);
rec_data.certCount = 1;
rec_data.pCertData = reciplist;
pXSign->XS_SetOption(XSO_RECIPIENT_CERTIFICATE_PATH_LIST, &rec_data);
pXSign->XS_Encrypt(hDossier);
A titkosításhoz használni kívánt címzett tanúsítványokat állíthatjuk be a pValue értékeként. pValue típusa:
typedef struct recipient_cert_list
{
XS_ULONG structSize; /* contains size of this struct */
XS_ULONG certCount; /* number of certificates */
XS_VOID_PTR_PTR pCertList; /* list of certificates */
} XS_RECIPIENT_CERT_LIST, XS_PTR XS_RECIPIENT_CERT_LIST_PTR;
A titkosított akta vagy dokumentum megtekintéséhez használni kívánt tanúsítványt kell megadni. A beállított kulcshoz tartozó tanúsítvány bekerül a címzettek közé az XS_Encrypt()függvény használata esetén (titkosításkor). pValue típusa:
typedef struct encrypting_certificate_struct {
XS_ULONG structSize;
XS_KEY_TYPE keyType;
XS_VOID_PTR pData;
} XS_ENCRYPTING_CERTIFICATE_DATA, XS_PTR XS_ENCRYPTING_CERTIFICATE_DATA_PTR;
XS_KEYFORM_PFX esetén:
typedef struct pfx_key_struct {
XS_ULONG structSize;
XS_CHAR_PTR pPath;
XS_CHAR_PTR pPassword;
} XS_PFX_KEY_DATA, XS_PTR XS_PFX_KEY_DATA_PTR;
XS_KEYFORM_PKCS11 esetén:
typedef struct pkcs11_key_struct {
XS_ULONG structSize;
XS_CHAR_PTR pPKCS11ModulePath;
XS_CHAR_PTR keyRef;
XS_ULONG keyRefType;
XS_CHAR_PTR pKeyPassword;
XS_CHAR_PTR pUserPIN;
XS_CHAR_PTR pContextSpecificPIN;
} XS_PKCS11_KEY_DATA, XS_PTR XS_PKCS11_KEY_DATA_PTR;
Az opció segítségével beállíthatjuk, hogy az e-Szignó ellenőrizze-e az archív időbélyeget. pValue típusa XS_BOOL kell legyen.
Amennyiben ezen opció értéke „XS_TRUE”, akkor az e-Szignó csak az aláírás (megbízható) időpontja után kibocsátott CRL-eket vagy OCSP válaszokat fogadja el. Alapértelmezett értéke „XS_TRUE”. Javasoljuk, hogy OCSP alapú visszavonás-ellenőrzés esetén használja az „XS_TRUE” beállítást. pValue típusa XS_BOOL kell legyen.
A paraméter az aláírás létrehozása során használt lenyomatképző algoritmust állítja be. A pValue paraméterben következő értékek szerepelhetnek:
A státuszüzenetek nyelvét állíthatjuk be a paraméter segítségével. pValue értéke egy string. A string lehetséges értékei: „eng”, „ger”, „hun”.
StartSession-nek átadandó dokumentumlista dokuemntum elemei
typedef struct esign_doc_url
{
XS_ULONG structSize;
XS_CHAR_PTR docName;
XS_CHAR_PTR docUrl;
XS_CHAR_PTR docUrlExpiry;
} XS_ESIGN_DOCUMENT, XS_PTR XS_ESIGN_DOCUMENT_PTR;
A létrehozandó e-aktáknak egyedi névteret lehet beállítani a paraméter segítségével. Ezen függvény segítségével hozhatunk létre a kliens alkalmazásban látható ügyviteli sémákhoz hasonló aktákat. pValue típusa:
typedef struct custom_namespace_struct {
XS_ULONG structSize;
XS_CHAR_PTR customNamespace;
XS_CHAR_PTR schemaLocation;
} XS_CUSTOM_NAMESPACE_DATA, XS_PTR XS_CUSTOM_NAMESPACE_DATA_PTR;
Az opció segítségével beállíthatjuk, hogy az e-Szignó ellenőrizze-e az OCSP válaszadó visszavonási állapotát. pValue típusa XS_BOOL kell legyen.
A paraméter az aláírás létrehozása során használt XAdES szabvány verzióját állítja be. A pValue paraméterben következő értékek szerepelhetnek:
Az alapértelmezett beállítás az 1.4.2-es szabvány. XSO_SIGNATURE_LEVE beállítás esetén a verzió kötelezően EN-1.0.0. szabvány szerinti kell, hogy legyen.
Az opció segítségével a PDF aláírások létrehozása során használt paraméterek alapértelmezett értékét változtathatjuk meg. A pValue típusa:
typedef struct pdf_signing_data_struct
{
XS_ULONG structSize;
XS_ULONG item;
XS_CHAR_PTR signReason;
XS_CHAR_PTR signLocation;
XS_ULONG signImgMode;
XS_CHAR_PTR signImgPath;
XS_BYTE_PTR signImgBuff;
XS_ULONG signImgBuffLen;
XS_LONG signImgPage;
XS_ULONG signImgAlign;
XS_ULONG signImgSize;
XS_ULONG signImgSizeMode;
XS_ULONG signImgPaddingX;
XS_ULONG signImgPaddingY;
XS_ULONG signImgPaddingXMode;
XS_ULONG signImgPaddingYMode;
XS_CHAR_PTR signImgTitle;
XS_ULONG signImgTitleMode;
XS_ULONG signImgTitleFontSize;
XS_ULONG signImgTitlePaddingX;
XS_ULONG signImgTitlePaddingY;
XS_ULONG signImgTitleAlign;
XS_BOOL signImgAdjPosDisable;
XS_ULONG pades;
XS_CHAR_PTR signaturePolicy;
XS_CHAR_PTR signaturePolicyOID;
XS_CHAR_PTR commitmentTypeOID;
XS_CHAR_PTR contentHintDescription;
XS_CHAR_PTR contentHintType;
} XS_PDF_SIGNING_DATA, XS_PTR XS_PDF_SIGNING_DATA_PTR;
XS_PDF_SIGNING_DATA data; memset(&data, 0, sizeof(data)); data.structSize = sizeof(data); data.item = XS_PDFSDI_IMG_PATH | XS_PDFSDI_ALIGN; data.signImgAlign = (XS_ULONG)RIGHT_BOTTOM; data.signImgPath = (XS_CHAR_PTR) "/home/user/img/test.png"; data.signImgTitle = (XS_CHAR_PTR) "Signed by: %CN%, signature time: %TSD%T%TSH%."; XS_SetOption(XSO_PDF_SIGNING_DATA, (XS_VOID_PTR)&data);
A paraméter az e-akta menésekor az XML kódolását állítja be. A pValue paraméterben következő értékek szerepelhetnek: XS_OUTPUT_ENCODING_UTF8 (UTF-8 kódolás) vagy XS_OUTPUT_ENCODING_LOCAL (lokális kódolás). Az alapértelmezett beállítás a XS_OUTPUT_ENCODING_LOCAL.
E paraméterrel beállítható, hogy az e-Szignó figyelembe vegye-e az aláírói tanúsítványban lévő kulcshasználat biteket az aláírás létrehozásakor vagy ellenőrzésekor. Amennyiben e paraméter értéke XS_TRUE, a program nem ellenőrzi a kulcshasználat mezőt, figyelmen kívül hagyja azt. Az alapértelmezett esetben (XS_FALSE beállítás) az aláírói tanúsítványban a kulcshasználat biteknek meg kell felelniük a vonatkozó szabványoknak, jogszabályoknak (a digitalSignature és/vagy a nonRepudiation bit kötelező).
E paraméterrel beállítható, hogy a program csak minősített aláírói tanúsítványokat fogadjon el. (Ilyenkor a tanúsítványban található qcStatements kiterjesztést ellenőrzi az e-Szignó.) Amennyiben e paraméter értéke XS_TRUE, a program csak megfelelő qcStatements kiterjesztéssel rendelkező aláírói tanúsítványokat fogad el.
Beállítja, hogy a PKCS #7/CMS alapú aláírások ellenőrzésekor és létrehozásakor a minimális követelmény a CAdES legyen-e (konkrétan: bekerüljön-e az aláírásba a CAdES által megkövetelt id-smime-aa-signingCertificate aláírt tulajdonság, ill. elfogadjon-e olyan aláírásokat, amelyekben az nem található). Amennyiben értéke XS_FALSE, a létrehozott aláírások a CAdES-nek nem felelnek meg (!), és ellenőrzéskor elfogadja a nem CAdES aláírásokat is. Alapértelmezett értéke XS_TRUE. Hatással van a XS_SignCM(), XS_VerifyCM() és XS_SignPDFDocument() függvényekre. (A XS_VerifyPDFDocument() függvény a PDF aláírás szabvány sajátosságai miatt mindig elfogadja a nem CAdES aláírásokat is.)
A paraméter segítségével a szimmetrikus kulcsú titkosításhoz használandó jelszót és titkosító algoritmust adhatjuk meg. A pValue típusa:
typedef struct encrypting_password_struct {
XS_ULONG structSize;
XS_CHAR_PTR password;
XS_CHAR_PTR key;
XS_CHAR_PTR encryptingAlgo;
} XS_ENCRYPTING_PASSWORD_DATA, XS_PTR XS_ENCRYPTING_PASSWORD_DATA_PTR;
A paraméter segítségével megadható, hogy SSL kapcsolódás esetén (pl. https címek használatakor) az e-Szignó ellenőrizze a távoli szerver tanúsítványát. Alapértelmezés szerint ki van kapcsolva ez a funkció.
A paraméter segítségével megadható, hogy SSL kapcsolódás esetén (pl. https címek használatakor) az e-Szignó ha ellenőrzi a távoli szerver tanúsítványát, akkor mely címek esetében nem kell ellenőriznie a visszavonási állapotot.
A megadott URL párok első tagjához történő kapcsolódás helyett minden esetben a második értékként megadott URL lesz használva. A párok és azok elemei is szóközzel legyenek elválasztva.
Példa a következő címek átirányításának megadása:
| http://nincs.ilyen.cim | → | http://teszt.e-szigno.hu/testroot2008ocsp |
| https://ca.e-szigno.hu/ocsp | → | http://rootocsp2009.e-szigno.hu |
”http://nincs.ilyen.cim http://teszt.e-szigno.hu/testroot2008ocsp https://ca.e-szigno.hu/ocsp http://rootocsp2009.e-szigno.hu”
A megadott elemek attribútumait ID típusúként kezeli az XSign.
typedef struct xml_id_struct {
XS_CHAR_PTR pElementNSHref;
XS_CHAR_PTR pElementName;
XS_CHAR_PTR pAttributeNSHref;
XS_CHAR_PTR pAttributeName;
} XS_XML_ID, XS_PTR XS_XML_ID_PTR;
typedef struct xml_id_list_struct {
XS_ULONG ulXMLIDCount;
XS_XML_ID_PTR pXMLIDs;
} XS_XML_ID_LIST, XS_PTR XS_XML_ID_LIST_PTR;
XS_XML_ID x[1];
XS_XML_ID_LIST xs;
x[0].pElementNSHref = NULL;
x[0].pElementName = (XS_CHAR_PTR)"RootElement";
x[0].pAttributeNSHref = NULL;
x[0].pAttributeName = (XS_CHAR_PTR)"id";
xs.ulXMLIDCount = 1;
xs.pXMLIDs = x;
xsRC = XS_SetOption(XSO_XML_ID_LIST, &xs);
if (xsRC != XSR_OK) {
fprintf(stderr, "XS_SetOption failed \n");
}
Beállítja, hogy a tanúsítványt lejáratokra ellenőrizni kell-e vagy sem.
Ezen opció segítségével az e-Szignó által létrehozott fájlokra vonatkozó MELASZ Ready (magyar interoperábilitási) szabvány verzióját lehet beállítani. Néhány esetben az ellenőrzési beállítások is módosulnak.
Amennyiben értéke XS_MELASZ_READY_1_0, az e-Szignó a friss ARL-ek (Authority Revocation List – Hitelesítés-szolgáltatói Visszavonási Lista) kibocsátását nem várja meg, és az OCSP válaszok ellenőrzésénél 30 perces kivárási időt alkalmaz. További érintett beállítások:
Amennyiben értéke XS_MELASZ_READY_2_0, a következő beállítások és értékek módosulnak:
Az XS_MELASZ_READY_NONE beállítással kikapcsolhatjuk a MELASZ Ready követelményeknek történő megfelelést.
Beállítható vele az attribútum tanúsítvány adatait kiválasztó callback függvény. A függvény típusdefiniciója a következő:
typedef XS_CALLBACK_FUNCTION(XS_ULONG, XS_ROLE_CERT_CALLBACK)( const XS_CHAR_PTR pDigest );
A visszatérési érték jelzi a művelet sikerességét, a bemeneti paraméter pedig az aláíráshoz használt tanúsítványhoz tartozó lenyomat.
Beállítható vele az attribútum tanúsítványhoz szükséges attribútumok tárolásához használt callback függvény. A függvény típusdefiniciója a következő:
typedef XS_CALLBACK_FUNCTION(XS_ULONG, XS_ROLE_CERT_FILE_STORE_CALLBACK)( const XS_CHAR_PTR pURL, const XS_BYTE_PTR pResponse, const XS_ULONG lResponseLength );
A visszatérési érték jelzi a művelet sikerességét, a bemeneti paraméterek sorrendben: URL, attribútumokat tartalmazó struktúra, struktúra hossza.
Segítségével a XSO_ROLE_CERT_CALLBACK függvényen keresztül beállítható az igénylést feldolgozó szerver URL-je és a kiválasztott attribútumok. A pValue típusa itt egy kételemű szövegtömböt reprezentál, ahol az első elem az URL, a második az attribútumok.
Segítségével a beállítható, hogy az alkalmazás aláírás létrehozáskor és ellenőrzéskor használja-e az EU Trust Service status List (TSL)-t. pValue típusa XS_TSL_SETTINGS_PTR. Ez a struktúra tartalmazza a használathoz szükséges összes paramétert.
typedef struct tsl_settings
{
XS_ULONG structSize;
XS_ULONG useTSL;
XS_CHAR_PTR tslCacheDir;
XS_CHAR_PTR rootTSLURL;
XS_CHAR_PTR TSLTrustedCertDir;
} XS_TSL_SETTINGS, XS_PTR XS_TSL_SETTINGS_PTR;
Ezen opció segítségével lehet beállítani, az archivumba küldéshez szükséges URL-t és az alapértelmezett autentikációs tanusítványt.
typedef struct archive_settings_struct
{
XS_ULONG structSize;
XS_CHAR_PTR archiveURL;
XS_CHAR_PTR archiveAuthCertContext;
} XS_ARCHIVE_SETTINGS, XS_PTR XS_ARCHIVE_SETTINGS_PTR;
Adott e-aktában megkeresi és visszaadja az első dokumentumra hivatkozó HANDLE –t. Amennyiben nincs az e-aktában dokumentum, a függvény visszatérési értéke XSR_END_OF_ITERATION.
Bemeneti paraméter. Azon e-aktára hivatkozó HANDLE, melyben a dokumentumot szeretnénk keresni.
Kimeneti paraméter. A megtalált első dokumentumra hivatkozó HANDLE–re mutató pointer.
Adott e-aktában megkeresi és visszaadja a következő dokumentumra hivatkozó HANDLE –t. Az XS_GetFirstDocumentHandle() függvénnyel együtt használandó, mellyel együtt végigiterálhatunk az e-aktában lévő dokumentumokon. Amennyiben nincs az e-aktában több dokumentum, a függvény visszatérési értéke XSR_END_OF_ITERATION.
Bemeneti paraméter. Azon e-aktára hivatkozó HANDLE, melyben a dokumentumot szeretnénk keresni.
Kimeneti paraméter. A megtalált dokumentumra hivatkozó HANDLE–re mutató pointer.
Adott e-aktán vagy dokumentumon lévő aláírások közül megkeresi és visszaadja az első aláírásra hivatkozó HANDLE –t. Amennyiben nincs az adott e-aktán vagy dokumentumon aláírás, a függvény visszatérési értéke XSR_END_OF_ITERATION.
Bemeneti paraméter. Azon e-aktára vagy dokumentumra hivatkozó HANDLE, melyen a az aláírásokat szeretnénk keresni.
Kimeneti paraméter. A megtalált aláírásra hivatkozó HANDLE–re mutató pointer.
Adott e-aktán vagy dokumentumon megkeresi és visszaadja a következő aláírásra hivatkozó HANDLE –t. Az XS_GetFirstSignatureHandle() függvénnyel együtt használandó, mellyel együtt végigiterálhatunk az e-aktán vagy dokumentumon lévő aláírásokon. Amennyiben nincs az e-aktán vagy dokumentumon több aláírás, a függvény visszatérési értéke XSR_END_OF_ITERATION.
Bemeneti paraméter. Azon e-aktára vagy dokumentumra hivatkozó HANDLE, melyen az aláírásokat szeretnénk keresni.
Kimeneti paraméter. A megtalált aláírásra hivatkozó HANDLE–re mutató pointer.
Adott e-aktáról, dokumentumról vagy aláírásról információkat kérhetünk le, a lekérdezni kívánt információ típusát az infoType paraméter határozza meg. A ppInfo változó pedig a visszaadott adatot tartalmazza. ppInfo típusa függ a lekérdezni kívánt adattól. ppInfo egy belső pufferre mutat, ezért használat után nem kell felszabadítani, hiszen az xsign újrahasznosítja a memória területet. Ennek az a következménye, hogy a puffer tartalma a lekérdezést követően felszabadul, ezért tanácsos a tartalmat kimenteni.
Bemeneti paraméter. Azon e-aktára, dokumentumra vagy aláírásra hivatkozó HANDLE, melyről az információkat szeretnénk lekérni.
Bemeneti paraméter. A lekérdezni kívánt információ típusát határozza meg.
Az infoType paraméter lehetséges értékei:
A dokumentum, vagy e-akta címét kérdezi le.
Az XS_HANDLE értékétől függően a dokumentum vagy a keret metaadatait kérhetjük le.
Minden esetben a ppInfo típusa XS_MAP_PTR kell, hogy legyen.
XS_MAP_PTR definíció szerint:
typedef struct map_struct {
XS_ULONG keyAndValueCount;
XS_KEY_AND_VALUE_PTR pKeyAndValueArray;
} XS_MAP, XS_PTR XS_MAP_PTR;
XS_KEY_AND_VALUE_PTR definíció szerint:
typedef struct key_and_value_struct {
XS_CHAR_PTR pKey;
XS_CHAR_PTR pValue;
} XS_KEY_AND_VALUE, XS_PTR XS_KEY_AND_VALUE_PTR;
Példa a használatra:
XS_RV xsRC = XSR_OK;
XS_OPEN_DOSSIER_DATA od_data;
XS_DOSSIER_HANDLE hDossier = 0;
XS_MAP_PTR pMap = NULL;
int i = 0;
XS_DOCUMENT_HANDLE hDoc = 0;
///////////////////////////////////////////
memset(&od_data, 0, sizeof(od_data));
od_data.structSize = sizeof(od_data);
od_data.pFilePath = "test.es3";
xsRC = pXSign->XS_OpenDossier(&od_data, &hDossier);
if (xsRC != XSR_OK) {
fprintf(stderr, "XS_OpenDossier failed, returned %d\n", xsRC);
goto end;
}
printf("Dossier custom metadata\n");
xsRC = pXSign->XS_GetInformation(hDossier, XSI_CUSTOM_METADATA, &pMap);
if (xsRC != XSR_OK) {
fprintf(stderr, "XS_GetInformation failed, returned %d\n", xsRC);
goto end;
}
for (i = 0; i < pMap->keyAndValueCount; i++) {
printf("%s: %s\n", pMap->pKeyAndValueArray[i].pKey, pMap->pKeyAndValueArray[i].pValue);
}
A handle értéke által hivatkozott objektum típusát adja meg.
A handle értéke által hivatkozott objektum méretét adja meg. Dokumentum esetén a beillesztett dokumentum beillesztés előtti méretét adja vissza.
A handle értéke által hivatkozott objektum létrehozási idejét adja meg.
A handle értéke által hivatkozott objektum MIME típusát adja meg.
A handle értéke által hivatkozott aláíráshoz fűzött megjegyzést adja vissza.
A handle értéke által hivatkozott aláírás XAdES típusát adja vissza.
A handle értéke által hivatkozott aláírásra vonatkozó aláírói tulajdonságok közül az aláírás helyéből a város mező értékét adja meg.
A handle értéke által hivatkozott aláírásra vonatkozó aláírói tulajdonságok közül az aláírás helyéből az ország mező értékét adja meg.
A handle értéke által hivatkozott aláírásra vonatkozó aláírói tulajdonságok közül az aláírás helyéből az irányítószám mező értékét adja meg.
A handle értéke által hivatkozott aláírásra vonatkozó aláírói tulajdonságok közül az aláírás helyéből a megye mező értékét adja meg.
A handle értéke által hivatkozott aláírásra vonatkozó aláírói tulajdonságok közül az aláíró szerepkörét adja meg.
A handle értéke által hivatkozott aláírásra vonatkozó aláírói tulajdonságok közül a kötelezettségvállalást adja meg.
A handle értéke által hivatkozott aláírás előtti megbízható időpontot adja vissza.
A handle értéke által hivatkozott aláírás utáni megbízható időpontot adja vissza.
A handle értéke által hivatkozott aláírói tanúsítvány láncára vonatkozó információkat ad vissza.
Visszaadja szöveges formában, hogy az aláíráshoz vannak-e csatolva visszavonási információk.
A handle által hivatkozott csomópont (dokumentum, aláírás) attribútumait adja vissza egy struktúrában. (Minden esetben a ppInfo típusa XS_ATTRIBUTES_PTR-re mutató pointer kell, hogy legyen.)
typedef struct attributes_struct {
XS_CHAR_PTR identifier;
XS_CHAR_PTR title;
XS_ULONG serial;
XS_ULONG mainType;
XS_ULONG subType;
XS_CHAR_PTR type;
XS_CHAR_PTR category;
XS_CHAR_PTR creationDate;
XS_CHAR_PTR mainMimeType;
XS_CHAR_PTR subMimeType;
XS_CHAR_PTR extension;
XS_ULONG length;
XS_ULONG xadesType;
XS_CHAR_PTR certificateInBase64;
XS_CHAR_PTR signerAlternativeName;
XS_CHAR_PTR certificateChainInfo;
XS_CHAR_PTR beforeSigningTime;
XS_CHAR_PTR afterSigningTime;
XS_CHAR_PTR signaturePolicy;
XS_CHAR_PTR signerApplication;
XS_BOOL isDocumentSafeViewed;
XS_BOOL isDocumentSignedByAServer;
XS_BOOL qualified;
XS_BOOL basedOnEPES;
} XS_ATTRIBUTES, XS_PTR XS_ATTRIBUTES_PTR;
A handle által hivatkozott csomópont (dokumentum, aláírás) attribútumait adja vissza egy struktúrában. Ez tulajdonképpen az XS_ATTRIBUTES struktúra kiterjesztett (és tovább terjeszthető) változata. (Minden esetben a ppInfo típusa XS_ATTRIBUTES_2_PTR-re mutató pointer kell, hogy legyen.)
typedef struct attributes_struct {
XS_ULONG structSize; /***/
XS_CHAR_PTR identifier;
XS_CHAR_PTR title;
XS_ULONG serial;
XS_ULONG mainType;
XS_ULONG subType;
XS_CHAR_PTR type;
XS_CHAR_PTR category;
XS_CHAR_PTR creationDate;
XS_CHAR_PTR mainMimeType;
XS_CHAR_PTR subMimeType;
XS_CHAR_PTR extension;
XS_ULONG length;
XS_ULONG xadesType;
XS_CHAR_PTR certificateInBase64;
XS_CHAR_PTR signerAlternativeName;
XS_CHAR_PTR certificateChainInfo;
XS_CHAR_PTR beforeSigningTime;
XS_CHAR_PTR afterSigningTime;
XS_CHAR_PTR signaturePolicy;
XS_CHAR_PTR signerApplication;
XS_BOOL isDocumentSafeViewed;
XS_BOOL isDocumentSignedByAServer;
XS_BOOL qualified;
XS_BOOL basedOnEPES;
XS_CHAR_PTR refType; /***/
XS_CHAR_PTR digestMethod; /***/
XS_BUFFER digestValue; /***/
XS_CHAR_PTR signatureAlgorithm; /***/
XS_CHAR_PTR signatureKeyDescription; /***/
XS_CHAR_PTR certSignAlgorithm; /***/
XS_ULONG xadesVersion; /***/
XS_CHAR_PTR afterFirstValidationTime; /***/
XS_CHAR_PTR lastArchiveTSTime; /***/
XS_CHAR_PTR lastArchiveTSValidityEnd; /***/
XS_SIGN_PROPERTIES_PTR signProperties; /***/
XS_QC_RESULT_PTR qcResult; /***/
XS_ULONG sourceOfTrust; /***/
XS_CHAR_PTR pSubjectOrgId; /***/
} XS_ATTRIBUTES_2, XS_PTR XS_ATTRIBUTES_2_PTR;
A struktúra elemei között az XS_ATTRIBUTES-hoz képest új elemeket /***/ jelöli. Ezek leírása (a többiét ld. az XS_ATTRIBUTES leírásánál):
Az aláírói tanúsítvány minősítettségét leíró XS_QC_RESULT struktúra:
typedef struct qc_result_struct {
XS_ULONG structSize;
XS_ULONG regulation;
XS_ULONG qualification;
XS_ULONG statement;
XS_DOUBLE limitValue;
XS_CHAR_PTR pLimitValueCurrency;
XS_ULONG retentionPeriod;
XS_ULONG types;
XS_MAP_PTR pPDSList;
XS_PSD2_QC_TYPE_PTR pPSD2QCType;
} XS_QC_RESULT, XS_PTR XS_QC_RESULT_PTR;
A struktúra elemei:
A tanúsítványhoz tartozó PSP szerepköröket és az NCA adatait tartalmazza.
typedef struct psd2_qc_type_struct {
XS_ROLES_OF_PSP_PTR pRolesOfPSP;
XS_CHAR_PTR pNCAName;
XS_CHAR_PTR pNCAId;
} XS_PSD2_QC_TYPE, XS_PTR XS_PSD2_QC_TYPE_PTR;
A tanúsítványhoz tartozó PSP szerepköröket tartalmazza.
typedef struct roles_of_psp_struct {
XS_ULONG ulCount;
XS_ROLE_OF_PSP_PTR pRoleOfPSP;
} XS_ROLES_OF_PSP, XS_PTR XS_ROLES_OF_PSP_PTR;
PSP szerepkört tartalmazó struktúra.
typedef struct role_of_psp_struct {
XS_CHAR_PTR roleOfPSPOid;
XS_CHAR_PTR roleOfPSPName;
} XS_ROLE_OF_PSP, XS_PTR XS_ROLE_OF_PSP_PTR;
A handle által hivatkozott dokumentumon, annak e-aktába illesztésekor végzett transzformációk listája. ppInfo a következőkben részletezett XS_TRANSFORMATIONS_PTR típusú pointerre kell, hogy mutasson.
typedef struct transformations_struct {
XS_ULONG ulCount;
XS_CHAR_PTR_PTR pTransformations;
} XS_TRANSFORMATIONS, XS_PTR XS_TRANSFORMATIONS_PTR;
Az aláírás által ellenjegyzett aláírások listáját adja vissza. ppInfo egy XS_HANDLE_ARRAY_PTR-re kell mutasson.
typedef struct handle_array_struct {
XS_ULONG ulCount;
XS_HANDLE_PTR phHandles;
} XS_HANDLE_ARRAY, XS_PTR XS_HANDLE_ARRAY_PTR;
Az aláíráshoz csatolt „PKI elemek”, időbélyegek, tanúsítványok, OCSP válaszok, CRL-ek listáját adja vissza. ppInfo egy XS_PKI_ITEM_LIST_PTR-re kell, hogy mutasson.
typedef struct pki_item_list_struct {
XS_ULONG ulCount;
XS_PKI_ITEM_PTR pPKIItem;
} XS_PKI_ITEM_LIST, XS_PTR XS_PKI_ITEM_LIST_PTR;
typedef struct pki_item_struct {
XS_ULONG structSize;
XS_CHAR_PTR pXMLIdentifier;
XS_CHAR_PTR pIssuerDN;
XS_ULONG ulType;
XS_VOID_PTR pItem;
} XS_PKI_ITEM, XS_PTR XS_PKI_ITEM_PTR;
typedef struct attached_ts_struct {
XS_ULONG structSize;
XS_ULONG version;
XS_ULONG accuracy_s;
XS_ULONG accuracy_us;
XS_ULONG accuracy_ms;
XS_CHAR_PTR pItemName;
XS_CHAR_PTR pSerialNumber;
XS_CHAR_PTR pStatusText;
XS_CHAR_PTR pNonce;
XS_CHAR_PTR pPolicyIdentifier;
XS_CHAR_PTR pHashAlgorithm;
XS_CHAR_PTR pMessageImprint;
XS_CHAR_PTR pTimeString;
XS_BUFFER TSACertificateInDER;
XS_BOOL rfc3161Compliant;
XS_CHAR_PTR pSignAlgorithm;
XS_CHAR_PTR pSignKeyDescription;
XS_CHAR_PTR pCertSignAlgorithm;
XS_QC_RESULT_PTR pQCResult;
} XS_ATTACHED_TS, XS_PTR XS_ATTACHED_TS_PTR;
typedef struct attached_ocsp_struct {
XS_ULONG structSize;
XS_ULONG version;
XS_CHAR_PTR pCertificateSubjectCN;
XS_CHAR_PTR pProducedAt;
XS_CHAR_PTR pResponderIdentifier;
XS_CHAR_PTR pResponseStatus;
XS_CHAR_PTR pResponseType;
XS_CHAR_PTR pSignature;
XS_OCSP_SINGLE_RESPONSE_LIST SingleResponses;
XS_EXTENSION_LIST Extensions;
XS_BUFFER CertificateInDER;
} XS_ATTACHED_OCSP, XS_PTR XS_ATTACHED_OCSP_PTR;
typedef struct ocsp_single_response_list {
XS_ULONG ulCount;
XS_OCSP_SINGLE_RESPONSE_PTR pSingleResponses;
} XS_OCSP_SINGLE_RESPONSE_LIST;
typedef struct ocsp_single_response {
XS_BOOL bNotGood;
XS_CHAR_PTR pCertificateStatus;
XS_CHAR_PTR pHashAlgorithm;
XS_CHAR_PTR pIssuerName;
XS_CHAR_PTR pIssuerKey;
XS_CHAR_PTR pCurrentUpdate;
XS_CHAR_PTR pNextUpdate;
XS_CHAR_PTR pSerialNumber;
XS_EXTENSION_LIST Extensions;
XS_CHAR_PTR pRevocationTime;
XS_CHAR_PTR pRevocationReason;
} XS_OCSP_SINGLE_RESPONSE, XS_PTR XS_OCSP_SINGLE_RESPONSE_PTR;
typedef struct extension_list {
XS_ULONG ulCount;
XS_EXTENSION_PTR pExtensions;
} XS_EXTENSION_LIST;
typedef struct extension {
XS_BOOL bCriticality;
XS_CHAR_PTR pOID;
XS_CHAR_PTR pName;
XS_CHAR_PTR pValue;
} XS_EXTENSION, XS_PTR XS_EXTENSION_PTR;
typedef struct attached_crl_struct {
XS_ULONG structSize;
XS_BUFFER CRLInDER;
XS_CHAR_PTR pIssuerDN;
} XS_ATTACHED_CRL, XS_PTR XS_ATTACHED_CRL_PTR;
typedef struct attached_certificate_struct {
XS_ULONG structSize;
XS_BUFFER CertificateInDER;
XS_CHAR_PTR pEmailAddress;
XS_CHAR_PTR pSubjectCN; XS_CHAR_PTR pSubjectDN;
} XS_ATTACHED_CERTIFICATE, XS_PTR XS_ATTACHED_CERTIFICATE_PTR;
typedef struct attached_attribute_certificate_struct {
XS_ULONG structSize;
XS_ULONG version;
XS_CHAR_PTR pIssuer;
XS_CHAR_PTR pSerial;
XS_CHAR_PTR pIssuerUID;
XS_CHAR_PTR pEntityName;
XS_ULONG ulDigestedObjectType;
XS_CHAR_PTR pDigestAlgorithm;
XS_CHAR_PTR pObjectDigest;
XS_CHAR_PTR pIssuerName;
XS_CHAR_PTR pSerialNumber;
XS_CHAR_PTR pNotBefore;
XS_CHAR_PTR pNotAfter;
XS_CHAR_PTR pSignature;
XS_CHAR_PTR pSignatureAlgorithm;
XS_CHAR_PTR pSignatureValue;
XS_ATTACHED_ATTRIBUTE_CERTIFICATE_ATTRIBUTE_LIST Attributes;
} XS_ATTACHED_ATTRIBUTE_CERTIFICATE, XS_PTR XS_ATTACHED_ATTRIBUTE_CERTIFICATE_PTR;
typedef struct attached_attribute_certificate_attribute_list {
XS_ULONG ulCount;
XS_ATTACHED_ATTRIBUTE_CERTIFICATE_ATTRIBUTE_PTR pAttributes;
} XS_ATTACHED_ATTRIBUTE_CERTIFICATE_ATTRIBUTE_LIST;
typedef struct attached_attribute_certificate_attribute_struct {
XS_CHAR_PTR pRoleName;
XS_ATTRIBUTE_ROLE_AUTHORITY_LIST RoleAuthorityList;
} XS_ATTACHED_ATTRIBUTE_CERTIFICATE_ATTRIBUTE, XS_PTR XS_ATTACHED_ATTRIBUTE_CERTIFICATE_ATTRIBUTE_PTR;
typedef struct attribute_role_authority_list {
XS_ULONG ulCount;
XS_CHAR_PTR_PTR pRoleAuthority;
} XS_ATTRIBUTE_ROLE_AUTHORITY_LIST;
Megjegyzés: WINCE operációs rendszeren nem támogatott ez az opció.
Kétmenetes aláírás létrehozásakor visszaadja az aláírás keret elkészítése (XS_Sign() hívás) után az aláíratlan lenyomatot base64 kódolt formában. ppInfo egy C stringre (char*) kell mutasson. Lásd még az XS_SetOption(XSO_SIGNING_CERTIFICATE) és az XS_SetInformation(XSI_SIGNED_HASH_B64ED) leírását.
Az aláírói tanúsítványban található DN mező értékét lehet lekérni.
A handle által hivatkozott aláíráshoz tartozó megjegyzés dokumentumot, és a hozzá tartozó attribútumait adja vissza egy struktúrában. (Minden esetben a ppInfo típusa XS_COMMENT_DOC_PTR-re mutató pointer kell, hogy legyen.)
A struktúra definíciója:
typedef struct comment_doc_struct {
XS_DOCUMENT_HANDLE documentHandle;
XS_ULONG fileSize;
XS_CHAR_PTR pTitle;
XS_CHAR_PTR pExtension;
XS_CHAR_PTR pMimeType;
} XS_COMMENT_DOC, XS_PTR XS_COMMENT_DOC_PTR;
XS_RV xsRC = XSR_OK;
XS_OPEN_DOSSIER_DATA od_data;
XS_DOSSIER_HANDLE hDossier = 0;
XS_SIGNATURE_HANDLE hSig = 0;
XS_COMMENT_DOC_PTR pCommentDoc = NULL;
XS_EXPORT_DOCUMENT_DATA edc_data;
/* opening dossier */
memset(&od_data, 0, sizeof(od_data));
od_data.structSize = sizeof(od_data);
od_data.pFilePath = "test_files/func_000028.es3";
xsRC = pXSign->XS_OpenDossier(&od_data, &hDossier);
if (xsRC != XSR_OK) {
goto end;
}
xsRC = pXSign->XS_GetFirstSignatureHandle(hDossier, &hSig);
if (xsRC != XSR_OK) {
goto end;
}
xsRC = pXSign->XS_GetInformation(hSig, XSI_COMMENT_DOC, (XS_VOID_PTR_PTR)&pCommentDoc);
if ((xsRC != XSR_OK) || !pCommentDoc) {
goto end;
}
if (strcmp(pCommentDoc->pExtension, "pdf")
|| strcmp(pCommentDoc->pMimeType, "application/pdf")
|| strcmp(pCommentDoc->pTitle, "Vélemény")
|| (pCommentDoc->fileSize != 87710)) {
/* .. */
}
/* exporting document */
memset(&edc_data, 0, sizeof(edc_data));
edc_data.structSize = sizeof(edc_data);
edc_data.pFilePath = "comdoc_clone.pdf";
xsRC = pXSign->XS_ExportDocument(pCommentDoc->documentHandle, &edc_data);
if (xsRC != XSR_OK) {
goto end;
}
A handle által hivatkozott PDF aláírás objektumról (XS_PDF_SIGNATURE_HANDLE) ad vissza információkat a következő struktúrában:
typedef struct pdf_attributes_struct {
XS_ULONG structSize;
XS_CHAR_PTR signerDN;
XS_CHAR_PTR name;
XS_CHAR_PTR signTime;
XS_CHAR_PTR revision;
XS_CHAR_PTR subfilter;
XS_BOOL hasSignatureTimeStamp;
XS_BOOL signatureCoversWholeDocument;
XS_ULONG sourceOfTrust;
} XS_PDF_ATTRIBUTES, XS_PTR XS_PDF_ATTRIBUTES_PTR;
A handle értéke által hivatkozott aláírói tanúsítvány lánca.
typedef struct certificate_chain {
XS_ULONG chainSize;
XS_CHAR_PTR_PTR ppCertInBase64Array;
} XS_CERTIFICATE_CHAIN, XS_PTR XS_CERTIFICATE_CHAIN_PTR;
A handle értéke által hivatkozott ASiC konténer típusa. Lehetséges értékei:
Részletesebb információ: ETSI TS 102 918 V1.2.1 bekezdés: 4.4.2
typedef XS_ULONG XS_ASIC_MAIN_TYPE, XS_PTR XS_ASIC_MAIN_TYPE_PTR;
A handle értéke által hivatkozott ASiC konténer altípusa és egyben a konténerben levő aláírások típusa. Lehetséges értékei:
Részletesebb információ: ETSI TS 102 918 V1.2.1 bekezdés: 4.4.2
typedef XS_ULONG XS_ASIC_SUB_TYPE, XS_PTR XS_ASIC_SUB_TYPE_PTR;
A handle értéke által hivatkozott ASiC konténer MIME típusát tartalmazó NULL végű karakterlánc.
typedef XS_CHAR XS_PTR XS_CHAR_PTR;
A handle értéke által hivatkozott ASiC konténer zip fejlécében szereplő kommentet tartalmazó NULL végű karakterlánc. Opcionálisan tartalmazhatja a konténer MIME típusát is.
typedef XS_CHAR XS_PTR XS_CHAR_PTR;
A handle értéke által hivatkozott ASiC dokumentum konténeren belüli elérési útját tartalmazó NULL végű karakterlánc.
typedef XS_CHAR XS_PTR XS_CHAR_PTR;
A handle értéke által hivatkozott XAdES aláírás azonosítóját tartalmazó NULL végű karakterlánc. Az aláírás az ASiC konténeren belül a META-INF könyvtárban egy XML fájlban található, amely több XAdES aláírást is tartalmazhat. Az XSI_ASIC_SIG_PATH_IN_CONTAINER és XSI_ASIC_SIG_ID együttvéve egyedien azonosít egy XAdES aláírást az ASiC konténeren belül. Az XSI_ASIC_SIG_ID értéke CAdES aláírások esetén nem értelmezett, értéke üres karakterlánc.
typedef XS_CHAR XS_PTR XS_CHAR_PTR;
A handle értéke által hivatkozott ASiC aláírást tartalmazó fájl ASiC konténeren belüli elérési útját tartalmazó NULL végű karakterlánc.
typedef XS_CHAR XS_PTR XS_CHAR_PTR;
A handle értéke által hivatkozott ASiC konténerben levő, memóriába beolvasott dokumentumok maximális mérete bájtokban. Az ezen értéknél tömörítetlenül kisebb dokumentumokat az API beolvassa a memóriába. A nagyobbakat pedig streamelve olvassa végig az egyes műveleteknél.
typedef unsigned long int XS_ULONG, XS_PTR XS_ULONG_PTR;
A handle által hivatkozott ASiC dokumentum vagy aláírás attribútumait adja vissza egy struktúrában. (Minden esetben a ppInfo típusa XS_ATTRIBUTES_2_PTR-re mutató pointer kell, hogy legyen.)
Az XS_ATTRIBUTES_2_PTR leírását lásd az XSI_ATTRIBUTES_2 leírásánál.
A handle által meghivatkozott akta névtere kérhető le. Ezen opció segítségével meghatározható az e-akta sémája. A visszaadott érték egy NULL értékkel lezárt karakterlánc.
A handle által meghivatkozott aláírás típusa kérdezhető le. Jelenleg PAdES és XAdES aláírások típusát lehet lekérdezni. Visszaadott értéke egy XS_LONG típusú érték.
Lehetséges visszaadott értékek:
Lehetséges visszaadott értékek:
enum AdESTypes
{
UNDEF = -1
, ADES_BES = 1
, ADES_EPES = 2
, ADES_T = 3
, ADES_C = 4
, ADES_X = 5
, ADES_X_L = 6
, ADES_A = 7
};
A handle által meghivatkozott PAdES aláírásról lekérdezhető, hogy LTV (Long Term Validation) támogató aláírás-e, azaz tartalmaz-e DSS (Document Security Store) elemet és Document Timestamp elemet. A visszatérési érték XS_BOOL típusú.
A titkosított dokumentum címzettjeinek a tanúsítványát és a titkosított kulcsokat adja vissza.
XS_RECIPIENT_INFOS_PTR definíció szerint:
typedef struct recipient_infos {
XS_ULONG structSize;
XS_ULONG count;
XS_CHAR_PTR_PTR certificates;
XS_CHAR_PTR_PTR encodedKey;
} XS_RECIPIENT_INFOS, XS_PTR XS_RECIPIENT_INFOS_PTR;
Az XS_HANDLE által meghatározott e-aktának, dokumentumnak vagy aláírásnak egyes adatait állíthatjuk be, a beállítani kívánt információ típusát az infoType paraméter határozza meg. A beállítani kívánt adatot pedig a pInfo változó tartalmazza. pInfo típusa függ a beállítani kívánt adattól.
Bemeneti paraméter. Azon e-aktára, dokumentumra vagy aláírásra hivatkozó HANDLE, melynek az adatait szeretnénk beállítani.
Bemeneti paraméter. A beállítani kívánt információ típusát határozza meg.
Az infoType paraméter lehetséges értékei:
A dokumentum, vagy e-akta címét állítja be. Ilyenkor a pInfo paraméter értéke egy C típusú string. Aláírt akta, vagy dokumentum címét nem lehet megváltoztatni. Aláírás címét, azaz az aláíró nevét sem lehet megváltoztatni.
Megjegyzés: WINCE operációs rendszeren nem támogatott ez az opció.
Az XS_HANDLE értékétől függően a dokumentum vagy a keret metaadatait állíthatjuk be. Aláírt akta, vagy dokumentum metaadatait nem lehet megváltoztatni.
Minden esetben a pInfo típusa XS_MAP_PTR kell, hogy legyen.
XS_MAP_PTR definíció szerint:
typedef struct map_struct {
XS_ULONG keyAndValueCount;
XS_KEY_AND_VALUE_PTR pKeyAndValueArray;
} XS_MAP, XS_PTR XS_MAP_PTR;
XS_KEY_AND_VALUE_PTR definíció szerint:
typedef struct key_and_value_struct {
XS_CHAR_PTR pKey;
XS_CHAR_PTR pValue;
} XS_KEY_AND_VALUE, XS_PTR XS_KEY_AND_VALUE_PTR;
XS_RV xsRC = XSR_OK;
XS_OPEN_DOSSIER_DATA od_data;
XS_DOSSIER_HANDLE hDossier = 0;
XS_SAVE_DOSSIER_DATA sd_data;
XS_DOCUMENT_HANDLE hDoc = 0;
XS_MAP map;
XS_KEY_AND_VALUE map_elems[2] = { 0 };
///////////////////////////////////////
memset(&od_data, 0, sizeof(od_data));
od_data.structSize = sizeof(od_data);
od_data.pFilePath = "test.es3";
xsRC = pXSign->XS_OpenDossier(&od_data, &hDossier);
if (xsRC != XSR_OK)
{
fprintf(stderr, "XS_OpenDossier failed, returned %d\n", xsRC);
goto end;
}
// set dossier metadata
memset(&map, 0, sizeof(map));
map.keyAndValueCount = 2;
map.pKeyAndValueArray = map_elems;
map_elems[0].pKey = "ElsőElem";
map_elems[0].pValue = "Tesztelő tartalom";
map_elems[1].pKey = "MásodikElem";
map_elems[1].pValue = "<?xml version='1.0' encoding='ISO-8859-2'?><Gyökér><Elem/></Gyökér>";
xsRC = pXSign->XS_SetInformation(hDossier, XSI_CUSTOM_METADATA, &map);
if (xsRC != XSR_OK)
{
fprintf(stderr, "XS_SetInformation failed, returned %d\n", xsRC);
goto end;
}
A kliens e-Szignó támogatást nyújt bizonyos speciális metaadatok kezelésére egy metaadat dialógus segítségével.
Ezen metaadatok egy elemben jelennek meg egy külön xml-be ágyazva. Erre az xml struktúrára az alábbiakban láthatunk példát.
<mireg:metadata xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:dcterms="http://purl.org/dc/terms/" xmlns:mireg="http://mireg.org/schema/1.0/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://mireg.org/schema/1.0/ http://mireg.org/model/XSD/metadata.xsd" about="#Object0"> <mireg:mireg> <dc:contributor>közreműködő tartalom</dc:contributor> <dc:coverage>tér-idő vonatkozás tartalom</dc:coverage> <dc:creator>létrehozó tartalom</dc:creator> <dc:description>tartalmi leírása tartalom</dc:description> <dc:format>formátum tartalom</dc:format> <dc:identifier>azonosító tartalom</dc:identifier> <dc:language>nyelv tartalom</dc:language> <dc:publisher>másolatkészítő személy neve </dc:publisher> <dc:relation>másolat készítési szabályzat URL</dc:relation> <dc:rights>jogok tartalom</dc:rights><dc:source>forrás tartalom</dc:source> <dc:subject>téma tartalom</dc:subject> <dc:title>cím tartalom</dc:title> <dc:type>típus tartalom</dc:type> <dcterms:available>2007-03-20T08:36:53Z</dcterms:available> <dcterms:extent>Other</dcterms:extent> <dcterms:valid>start=2007-03-20T08:36:53Z</dcterms:valid> </mireg:mireg></mireg:metadata>
Ha ezt az XML-t metadata néven illesztjük be, akkor a kliens e-Szignó által megjeleníthető e-aktát kapunk.
Megjegyzés: WINCE operációs rendszeren nem támogatott ez az opció.
Az XS_HANDLE értékétől függően a dokumentum vagy a keret metaadatait állíthatjuk be. Aláírt akta, vagy dokumentum metaadatait nem lehet megváltoztatni.
Minden esetben a pInfo típusa XS_METADATA_MAP_PTR kell, hogy legyen.
XS_METADATA_MAP_PTR definíció szerint:
typedef struct metadata_map_struct {
XS_ULONG metadataCount;
XS_METADATA_PTR_PTR ppMetadataArray;
} XS_METADATA_MAP, XS_PTR XS_METADATA_MAP_PTR;
XS_METADATA_PTR definíció szerint:
typedef struct custom_metadata_struct {
XS_ULONG structSize;
XS_CHAR_PTR pKey;
XS_CHAR_PTR pDisplayName;
XS_CHAR_PTR pValue;
} XS_METADATA, XS_PTR XS_METADATA_PTR;
XS_RV xsRC = XSR_OK;
XS_OPEN_DOSSIER_DATA od_data;
XS_DOSSIER_HANDLE hDossier = 0;
XS_SAVE_DOSSIER_DATA sd_data;
XS_DOCUMENT_HANDLE hDoc = 0;
XS_METADATA_MAP map;
XS_METADATA map_elem1, map_elem2;
XS_METADATA_PTR pMetadataElements[2] = { &map_elem1, &map_elem2 };
memset(&od_data, 0, sizeof(od_data));
od_data.structSize = sizeof(od_data);
od_data.pFilePath = "test_files/func_000036.es3";
xsRC = pXSign->XS_OpenDossier(&od_data, &hDossier);
if (xsRC != XSR_OK)
{
fprintf(stderr, "XS_OpenDossier failed, returned %d\n", xsRC);
goto end;
}
memset(&map, 0, sizeof(map));
map.metadataCount = 2;
map.ppMetadataArray = &pMetadataElements;
map_elem1.structSize = sizeof(map_elem1);
map_elem1.pKey = "ElsőjElem";
map_elem1.pDisplayName = "ElsőMegjelenítendő";
map_elem1.pValue = "Tesztelőjtartalom";
map_elem2.structSize = sizeof(map_elem2);
map_elem2.pKey = "MásodikÚjElem";
map_elem2.pDisplayName = "MásodikMegjelenítendő";
map_elem2.pValue = "MásodikTartalom";
xsRC = pXSign->XS_SetInformation(hDossier, XSI_CUSTOM_METADATA_2, &map);
if (xsRC != XSR_OK)
{
fprintf(stderr, "XS_SetInformation failed, returned %d\n", xsRC);
goto end;
}
Megjegyzés: WINCE operációs rendszeren nem támogatott ez az opció.
XML-be illesztendő aláírás létrehozása (XS_InsertSignature() hívás) előtt hozzáad egy elemet az aláírandó (TBS – To Be Signed) objektumok listájához. pInfo típusa a következőkben részletezett XS_SIGNED_OBJECT_PTR kell legyen.
typedef struct signed_object {
XS_ULONG structSize;
XS_CHAR_PTR pURI;
XS_SX_TRANSFORM transformation;
XS_CHAR_PTR pMIMEType;
} XS_SIGNED_OBJECT, XS_PTR XS_SIGNED_OBJECT_PTR;
Lásd még az XS_InsertSignature() leírását.
Megjegyzés: WINCE operációs rendszeren nem támogatott ez az opció.
XML-be illesztendő aláírás létrehozása (XS_InsertSignature() hívás) előtt ezen információtípus használatával regisztrálhatjuk be az aláíráskor megadandó XPath kifejezésben használandó XML névtér prefixeket. A pInfo paraméter típusa XS_KEY_AND_VALUE_PTR.
typedef struct key_and_value_struct {
XS_CHAR_PTR pKey;
XS_CHAR_PTR pValue;
} XS_KEY_AND_VALUE, XS_PTR XS_KEY_AND_VALUE_PTR;
Lásd még az XS_InsertSignature() leírását.
Megjegyzés: WINCE operációs rendszeren nem támogatott ez az opció.
Kétmenetes aláírás létrehozásakor ezen információtípus segítségével állíthatjuk be az aláírt lenyomat értékét a félkész aktában. A folyamat befejezése képpen az elkészült aláírás ellenőrzésre kerül, tehát a vonatkozó beállítások (megbízható tanúsítványok, visszavonás-ellenőrzés) szükségesek. pInfo egy NULL karakterrel lezárt karaktersorozat (C string), mely az aláírt lenyomatot tartalmazza base64 kódolva.
A kétmenetes aláírás lényege, hogy az aláírást az e-Szignó program két menetben hozza létre: az első menetben a megadott tanúsítvánnyal létrehozza az aláírás XML keretét a kötelezően aláírandó metaadatokkal, valamint kiszámítja az aláírandó adatok lenyomatát, amit egy külső alkalmazásnak (pl. weboldalba illesztett ActiveX control vagy Java applet) átad aláírásra. A második menetben a külső alkalmazás által aláírt lenyomatot beilleszti a félkész aláírásba, majd ellenőrzi az aláírói tanúsítványt, esetleg időbélyeggel (XAdES-T) bőviti az aláírást.
Az aláíráshoz szükséges magánkulcs és az aláíró program fizikailag elkülönül, tipikusan a magánkulcs a kliens géphez csatlakoztatott kártyaolvasóba helyezett kártyán, az aláíró program (e-Szignó SDK) pedig a browser „túloldalán”, a HTTPS kapcsolatot kiszolgáló szervergépen fut. A kliens nem tudja a magánkulcsát eljuttatni a szerverre, hisz az „be van zárva a kártyába”, így a kliens e-Szignón kívül csak a kétmenetes aláírás marad, mint megoldás.
A kétmenetes aláírás pár előnye:
A kétmenetes aláírás használatának feltétele, hogy a kliens megbizonyosodjon és megbízzon a szerver által számára elküldött lenyomat valódiságában, pl. szerver-autentikált HTTPS (SSL) kapcsolat szükséges!
Ld. még az e-Szignó parancssori interfészének dokumentációját (doc\eszigno3_ref.html).
XS_NEW_DOSSIER_DATA ndd; XS_DOSSIER_HANDLE hDossier = 0; XS_SIGNING_CERTIFICATE_DATA scd; XS_CERT_KEY_DATA ckd; char* pUnsigned = NULL; char* pSigned = NULL; /* Általános beállítások. */ XS_SetOption(XSO_WIN_USE_CERT_STORE, (XS_VOID_PTR)XS_FALSE); XS_SetOption(XSO_TRUSTED_CERT_DIR, (XS_VOID_PTR)"test_files/trusted_certs"); XS_SetOption(XSO_INTERMEDIATE_CERT_DIR, (XS_VOID_PTR)"test_files/intermediate_certs"); XS_SetOption(XSO_WORK_SILENT, (XS_VOID_PTR)XS_FORCE_SILENT); memset(&ndd, 0, sizeof(ndd)); ndd.structSize = sizeof(ndd); ndd.pTitle = "E-akta"; XS_NewDossier(&ndd, &hDossier); /* csak az aláíró tanúsítványát állítjuk be, a magánkulcsát nem; innen tudja az e-Szignó, hogy kétmenetes aláírás készül. A tanúsítványt pl. a kliens választotta ki ActiveX controlban és felküldte HTTP POST-tal. Mi lementettük a lenti elérési útra.*/ memset(&scd, 0, sizeof(scd)); scd.structSize = sizeof(scd); scd.keyType = XS_KEYFORM_CERT; memset(&ckd, 0, sizeof(ckd)); ckd.structSize = sizeof(ckd); ckd.pPath = "test_files/func_000018.cer"; scd.pData = &ckd; XS_SetOption(XSO_SIGNING_CERTIFICATE, &scd); /* Félkész keretaláírás létrehozása: */ XS_SignFrame(hDossier, NULL, NULL); /* Az aláíratlan lenyomat kinyerése. */ XS_GetInformation( hDossier , XSI_UNSIGNED_HASH_B64ED , (XS_VOID_PTR_PTR)&pUnsigned ); /* ... a pUnsigned tartalmazza az aláíratlan hasht. Ezt eljuttatjuk valamilyen módon a klienshez, pl. a fenti HTTP POST-ra válaszul. Ekkor a kliens a nála lévő magánkulccsal aláírja a hash-t, majd visszaküldi. Belekerül a pSigned változóba */ ... ... ... /* Az aláírt lenyomat beállítása. Ilyenkor a beállított XAdES típusnak (XSO_XADES_TYPE) megfelelő aláírás készül! * / XS_SetInformation( hDossier , XSI_SIGNED_HASH_B64ED , (XS_VOID_PTR)pSigned ); /* Elkészült az aláírás. */
PDF fájlokat nem csak e-aktán belül lehet aláírni, hanem közvetlenül a fájt is aláírhatjuk, hiszen a PDF szabvány (az 1.3 verzió óta) ezt megengedi. Ennek a függvénynek a segítségével tudunk közvetlenül e-akta létrehozás nélkül PDF aláírást létrehozni. Ha a visszavonás-ellenőrzési mód nincs megadva, OCSP/CRL-t használ.
Ez a funkció WinCE operációs rendszer alatt nincs implementálva.
Bemeneti paraméter. A hivatkozott struktúra definíciója alább látható.
typedef struct sign_pdf_struct
{
XS_ULONG structSize;
XS_INPUT_PDF_DATA_PTR pInputPDF;
XS_OUTPUT_PDF_DATA_PTR pOutputPDF;
} XS_SIGN_PDF_DATA, XS_PTR XS_SIGN_PDF_DATA_PTR;
A pInputPDF és a pOutputPDF struktúra definíciója az alábbiakban látható.
typedef struct io_struct
{
XS_ULONG structSize;
XS_CHAR_PTR pFilePath;
XS_BUFFER_PTR pBuffer;
} XS_IO_DATA, XS_PTR XS_IO_DATA_PTR;
, ahol pBuffer definíciója:
typedef struct buffer_struct
{
XS_BYTE_PTR pBuffer;
XS_ULONG bufferLength;
} XS_BUFFER, XS_PTR XS_BUFFER_PTR;
CMS aláírás készítése.
Megjegyzés: Ez a funkció WinCE operációs rendszer alatt nincs implementálva.
Bemeneti paraméter. A hivatkozott struktúra definíciója alább látható.
typedef struct sign_cm_struct
{
XS_ULONG structSize;
XS_IO_DATA XS_PTR pInput;
XS_IO_DATA XS_PTR pOutput;
XS_CHAR_PTR pContentType;
XS_BOOL detached;
} XS_SIGN_CM_DATA, XS_PTR XS_SIGN_CM_DATA_PTR;
CMS aláírás ellenőrzése.
Megjegyzés: Ez a funkció WinCE operációs rendszer alatt nincs implementálva.
Bemeneti paraméter. A hivatkozott struktúra definíciója alább látható.
typedef struct verify_cm_struct
{
XS_ULONG structSize;
XS_IO_DATA XS_PTR pInput;
XS_IO_DATA XS_PTR pContent;
XS_IO_DATA XS_PTR pOutput;
} XS_VERIFY_CM_DATA, XS_PTR XS_VERIFY_CM_DATA_PTR;
Átvételi elismervényt készít egy adott elektronikus aktáról a függvény
Megjegyzés: Ez a funkció WinCE operációs rendszer alatt nincs implementálva.
Bemeneti paraméter. A hivatkozott struktúra definíciója alább látható.
typedef struct create_acknowledgement_data_struct {
XS_ULONG structSize;
XS_CHAR_PTR pFilePath;
XS_BUFFER_PTR pFile;
XS_INSERT_DOCUMENT_DATA_PTR pCommentDoc;
} XS_CREATE_ACKNOWLEDGEMENT_DATA
, XS_PTR XS_CREATE_ACKNOWLEDGEMENT_DATA_PTR;
typedef struct insert_document_struct
{
XS_ULONG structSize;
XS_CHAR_PTR pFilePath;
XS_BUFFER_PTR pBuffer;
XS_CHAR_PTR pMIMEType;
XS_CHAR_PTR pTitle;
} XS_INSERT_DOCUMENT_DATA, XS_PTR XS_INSERT_DOCUMENT_DATA_PTR;
Bármilyen XML-ben képes aláírást elhelyezni a funkció. Az XS_SetInformation() függvény XSI_ADD_TBS_OBJECT paraméterének segítségével határozhatjuk meg azokat a csomópontokat, melyeket alá szeretnénk írni. Az XS_InsertSignature() függvény meghívása után ismét be kell állítani az aláírni kívánt csomópontokat, ha újra szeretnénk használni a metódust. Ez egyben azt is jelenti, hogy nem kell resetelni a korábban beállított csomópontokat az utolsó aláírás után.
Bemeneti paraméter. Az aláírni kívánt XML-re hivatkozó HANDLE-t kell megadni, amit az XS_OpenDossier segítségével kaphatunk meg.
Bemeneti paraméter. Az aláírás körülményeit határozhatjuk meg ezen paraméter segítségével. A struktúra definícióját az alábbiakban láthatjuk.
typedef struct insert_signature_data_struct
{
XS_ULONG structSize;
XS_CHAR_PTR pXPath;
XS_SX_INSERT_AS sigLocInsertAs;
XS_BOOL addSchemaLocation;
XS_SIGN_PROPERTIES_PTR pSignProperties;
} XS_INSERT_SIGNATURE_DATA, XS_PTR XS_INSERT_SIGNATURE_DATA_PTR;
XS_OPEN_DOSSIER_DATA input; XS_KEY_AND_VALUE ns; XS_DOSSIER_HANDLE hDossier = 0; XS_INSERT_SIGNATURE_DATA sxd; XS_SAVE_DOSSIER_DATA output; memset(&input, 0, sizeof(input)); input.structSize = sizeof(input); input.pFilePath = "test_files/teszt.xml"; input.passAllXMLs = XS_TRUE; XS_OpenDossier(&input, &hDossier); memset(&ns, 0, sizeof(ns)); ns.pKey = "n1"; ns.pValue = "http://teszt.e-szigno.hu/1#"; XS_SetInformation(hDossier, XSI_REGISTER_XPATH_NS, &ns); memset(&object, 0, sizeof(object)); object.structSize = sizeof(object); object.pURI = "#Node1"; object.transformation = XS_SX_TR_BASE64; object.pMIMEType = "text/plain"; XS_SetInformation(hDossier, XSI_ADD_TBS_OBJECT, &object); object.pURI = "#Node0"; object.transformation = XS_SX_TR_C14N; object.pMIMEType = NULL; XS_SetInformation(hDossier, XSI_ADD_TBS_OBJECT, &object); memset(&sxd, 0, sizeof(sxd)); sxd.pXPath = "/n1:Gyökér"; XS_InsertSignature(hDossier, &sxd); memset(&output, 0, sizeof(output)); output.structSize = sizeof(output); output.pFilePath = "new1.xml"; XS_SaveDossier(hDossier, &output);
A modul teljes funkcionalitásának eléréséhez regisztrációs fáj szükséges. Ez a függvény automatikusan elkészíti a regisztrációs fájlt a regisztrációs kulcs segítségével.
Megjegyzés: Ez a funkció WinCE operációs rendszer alatt nincs implementálva.
Bemeneti paraméter. Regisztrációs struktúrára mutató pointer. Ebben a struktúrában kell meghatározni a regisztráció körülményeit. A struktúra leírása az alábbiakban található.
typedef struct reg_data_struct
{
XS_ULONG structSize;
XS_CHAR_PTR pRegKey;
XS_CHAR_PTR pRegURL;
XS_IO_DATA_PTR pOutput;
} XS_REGISTER_DATA, XS_PTR XS_REGISTER_DATA_PTR;
Ennek a funkciónak a segítségéve, a paraméterektől függően törölhetünk egy dokumentumot vagy aláírást. A dokumentumot vagy aláírást csak akkor törölhetjük, ha a dosszié nincs aláírva.
Bemeneti paraméter. A törlendő objektumot adja meg. A struktúra felépítése a következő:
typedef struct delete_data_struct
{
XS_ULONG structSize;
XS_HANDLE handle;
} XS_DELETE_DATA, XS_PTR XS_DELETE_DATA_PTR;
Kiüríti a megadott e-aktához tartozó URL gyorsítótárat (cache-t).
Bemeneti paraméter. Azon e-aktára hivatkozó HANDLE, amelyhez tartozó URL cache-t üríteni szeretnénk.
Titkosítja a megadott e-aktát vagy dokumentumot. A titkosításhoz az XSO_RECIPIENT_CERTIFICATE_LIST opcióval megadott címzett tanúsítványokat használja. Lásd még a hivatkozott opció példáját.
Bemeneti paraméter. Azon e-aktára vagy dokumentumra hivatkozó HANDLE, amelyet titkosítani szeretnénk.
Ellenőrzi a megadott tértivevényt.
Bemeneti paraméter. Azon tértivevényre hivatkozó HANDLE, melyet ellenőrizni szeretnénk.
Bemeneti paraméter. Az ellenőrizendő tértivevényhez tartozó e-aktát kell megadni A struktúra felépítése a következő:
typedef struct check_acknowledgement_struct
{
XS_ULONG structSize;
XS_CHAR_PTR pFilePath;
XS_BUFFER_PTR pBuffer;
} XS_CHECK_ACKNOWLEDGEMENT_DATA, XS_PTR XS_CHECK_ACKNOWLEDGEMENT_DATA_PTR;
Az aláíráshoz használandó OpenSSL engine-t lehet beállítani.
Bemeneti paraméter. Az engine paramétereit lehet megadni a paraméter segítségével A struktúra felépítése a következő:
typedef struct set_engine_struct
{
XS_ULONG structSize;
XS_CHAR_PTR pEngineID;
XS_CHAR_PTR pPreInitCommands;
XS_CHAR_PTR pPostInitCommands;
} XS_ENGINE_DATA, XS_PTR XS_ENGINE_DATA_PTR;
Megnyit egy PDF dokumentumot és visszaadja a dokumentum objektumra vonatkozó handle-t.
Bemeneti paraméter. A PDF dokumentum megnyitásához szükséges adatokat adhatjuk meg a segítségével.
typedef struct open_pdf_document_data_struct
{
XS_ULONG structSize;
XS_CHAR_PTR pFilePath;
XS_BUFFER_PTR pBuffer;
XS_BOOL bValidatePDF;
XS_CHAR_PTR pPassword;
} XS_OPEN_PDF_DOCUMENT_DATA, XS_PTR XS_OPEN_PDF_DOCUMENT_DATA_PTR;
Kimeneti paraméter. A megadott pointer által mutatott XS_PDF_DOCUMENT_HANDLE típusú memóriaterület az újonnan létrehozott PDF dokumentum objektum handle-jét kapja értékül.
A megadott PDF dokumentum objektumot felszabadítja és törli a memóriából. Figyelem! A dokumentumon lévő aláírások is törlődnek, tehát a rájuk vonatkozó XS_PDF_SIGNATURE_HANDLE-öket már nem lehet használni!
Bemeneti paraméter. Későbbi használatra fenntartva, értéke legyen NULL.
Be- és kimeneti paraméter. A megadott pointer által mutatott XS_PDF_DOCUMENT_HANDLE által hivatkozott PDF dokumentum objektum felszabadításra kerül és a handle XS_INVALID_HANDLE értéket kap.
Elmenti a megadott PDF dokumentum objektumot.
Bemeneti paraméter. A menteni kívánt PDF dokumentum objektumra hivatkozó handle.
Bemeneti paraméter. A PDF dokumentum mentéséhez szükséges adatokat adhatjuk meg a segítségével.
typedef struct save_pdf_document_data_struct
{
XS_ULONG structSize;
XS_CHAR_PTR pFilePath;
XS_BUFFER_PTR pBuffer;
} XS_SAVE_PDF_DOCUMENT_DATA, XS_PTR XS_SAVE_PDF_DOCUMENT_DATA_PTR;
Aláírja a megadott PDF dokumentum objektumot. Ha a visszavonás-ellenőrzési mód nincs megadva, OCSP/CRL-t használ.
Bemeneti paraméter. Az aláírni kívánt PDF dokumentum objektumra hivatkozó handle.
Bemeneti paraméter. A PDF dokumentum aláírásához szükséges adatokat adhatjuk meg a segítségével. Értéke NULL lehet, ekkor az alapértelmezett beállításokkal történik az aláírás. A XS_SIGN_PDF_DOCUMENT_DATA struktúra a következőképpen fest:
typedef struct sign_pdf_doc_data {
XS_ULONG structSize;
XS_ULONG preserveSize;
} XS_SIGN_PDF_DOCUMENT_DATA, XS_PTR XS_SIGN_PDF_DOCUMENT_DATA_PTR;
Kimeneti paraméter, opcionális, tehát értéke lehet NULL. A megadott pointer által mutatott XS_PDF_SIGNATURE_HANDLE típusú memóriaterület az újonnan létrehozott PDF aláírás objektum handle-jét kapja értékül.
Ellenőrzi a megadott PDF dokumentumban lévő összes aláírást. Az ellenőrzött aláírások handle-jeit visszaadja. A folyamat megegyezik az XS_GetSignedPDFDocument által visszaadott összes aláírást tartalmazó tömb elemein meghívott XS_VerifyPDFSignature hívással. Az ellenőrzést az első hibás aláírásig végzi.
Bemeneti paraméter. Az ellenőrizni kívánt PDF dokumentum objektumra hivatkozó handle.
Bemeneti paraméter. A PDF dokumentum ellenőrzéséhez szükséges adatokat adhatjuk meg a segítségével. Értéke NULL lehet, ekkor az alapértelmezett beállításokkal történik az ellenőrzés. A XS_VERIFY_PDF_DOCUMENT_DATA struktúra a következőképpen fest:
typedef struct verify_pdf_doc_data {
XS_ULONG structSize;
XS_BOOL ignoreUnknownSubFilters;
} XS_VERIFY_PDF_DOCUMENT_DATA, XS_PTR XS_VERIFY_PDF_DOCUMENT_DATA_PTR;
Az XSign a legelterjedtebb subFiltereket támogatja, nevezetesen:
Kimeneti paraméter, opcionális, tehát értéke lehet NULL. A megadott pointer által mutatott XS_HANDLE_ARRAY típusú struktúrát feltölti az ellenőrzött PDF aláírás objektumok handle-jeivel. Amennyiben az aláírások között szerepel legalább egy hibás aláírás, úgy az értéke NULL.
Az XS_HANDLE_ARRAY struktúra definíciója:
typedef struct handle_array {
XS_ULONG ulCount;
XS_HANDLE_PTR phHandles;
} XS_HANDLE_ARRAY, XS_PTR XS_HANDLE_ARRAY_PTR;
A pPDFSignatureHandles által hivatkozott tömb csak a következő XSign hívásig érvényes, ezért a benne visszaadott handle-öket el kell másolni a memóriaterületről:
memcpy(pNewHandles, pPDFSignatureHandles->phHandles, pPDFSignatureHandles->ulCount);
Visszaadja az adott aláírás által aláírt PDF dokumentum verziót.
Bemeneti paraméter. A PDF aláírás objektum handle-je.
Későbbi használatra fenntartva. Értéke legyen NULL.
Kimeneti paraméter. A megadott pointer által mutatott XS_PDF_DOCUMENT_HANDLE típusú memóriaterület a lekért dokumentum objektum handle-jét kapja értékül.
Az aláírt PDF dokumentumhoz tartozó összes aláírást visszaadja egy tömbben.
Bemeneti paraméter. A PDF dokumentum handle-je.
Az aláírások listája, ahol
typedef struct handle_array_struct {
XS_ULONG ulCount;
XS_HANDLE_PTR phHandles;
} XS_HANDLE_ARRAY, XS_PTR XS_HANDLE_ARRAY_PTR;
A handle által hivatkozott PDF aláírást ellenőrzi le.
Bemeneti paraméter. A PDF aláírás objektum handle-je. Ezt az aláírást fogja leellenőrizni a metódus.
Az aláírás ellenőrzés körülményeit beállító paramétereket tartalmazó struktúrára mutató pointer, ahol
typedef struct verify_pdf_doc_data {
XS_ULONG structSize;
XS_BOOL ignoreUnknownSubFilters;
} XS_VERIFY_PDF_DOCUMENT_DATA, XS_PTR XS_VERIFY_PDF_DOCUMENT_DATA_PTR;
Az XSign a legelterjedtebb subFiltereket támogatja, nevezetesen:
Visszaadja az adott aláíráshoz tartozó aláírói tanúsítványt.
Bemeneti paraméter. A PDF aláírás objektum handle-je, melynek a tanúsítványát szeretnénk lekérni.
Az aláíráshoz tartozó aláírói tanúsítványt tartalmazza.
Visszaadja az adott aláíráshoz tartozó aláíratlan lenyomatot.
Bemeneti paraméter. A PDF aláírás objektum handle-je, melynek a tanúsítványát szeretnénk lekérni.
Kimeneti paraméter. Az aláírásból kiolvasandó aláíratlan lenyomatot tartalmazza.
typedef struct get_unsigned_hash_pdf_signature_data {
XS_ULONG structSize;
XS_CHAR_PTR_PTR ppBASE64EncodedUnsignedHash;
} XS_GET_UNSIGNED_HASH_PDF_SIGNATURE_DATA, XS_PTR XS_GET_UNSIGNED_HASH_PDF_SIGNATURE_DATA_PTR;
Beállítja az adott aláíráshoz az aláírt lenyomatot. Szükség esetén kiterjeszti az aláírást a megadott típusúra.
Bemeneti paraméter. A PDF aláírás objektum handle-je, melynek a tanúsítványát szeretnénk lekérni.
Bemeneti paraméter. Az aláírásba beillesztendő aláírt lenyomatot tartalmazza.
typedef struct set_signed_hash_pdf_signature_data {
XS_ULONG structSize;
XS_CHAR_PTR pBASE64EncodedSignedHash;
} XS_SET_SIGNED_HASH_PDF_SIGNATURE_DATA, XS_PTR XS_SET_SIGNED_HASH_PDF_SIGNATURE_DATA_PTR;
Visszaállítja a legutolsó aláírás vagy időbélyegzés előtti PDF dokumentumot. Teljes archív aláírás esetén a teljes aláírás törléséhez két hívás szükséges (első hívás az archív időbélyegre, második hívás az aláírásra).
Bemeneti paraméter. A PDF dokumentum objektum leírója.
E-akta hitelességének ellenőrzése. A függvény ellenőrzi, hogy az e-akta nem üres-e, valamint hogy az összes dokumentum aláírása érvényes-e. A keretaláírás az összes dokumentum aláírásának számít. Az időbélyegek nem számítanak aláírásnak. Rekurzív módban az e-aktába illesztett e-akta típusú dokumentumok belsejét is ellenőrzi. Amennyiben egy érvénytelen aláírás „kívül” egy érvényessel „védve van”, a program elfogadja az aktát. (Pl. a dokumentum aláírása lejárt, de a keretaláírás érvényes.) Ez a működés felülbírálható a XS_VALIDATE_DOSSIER_DATA.forceValidateAllSignatures paraméter használatával.
Bemeneti paraméter. Az ellenőrizendő e-aktára hivatkozó HANDLE.
Bemeneti paraméter. Az e-akta ellenőrzéséhez szükséges paramétereket tartalmazó struktúrára mutató pointer.
typedef struct validate_dossier_data {
XS_ULONG structSize;
XS_BOOL recursive;
XS_BOOL forceValidateAllSignatures;
XS_BOOL showProperties;
XS_ULONG truncateToXAdESType;
XS_ULONG addTimestamp;
XS_BOOL checkDocumentFormat;
XS_IO_DATA_PTR pOut;
} XS_VALIDATE_DOSSIER_DATA, XS_PTR XS_VALIDATE_DOSSIER_DATA_PTR;
Állomány feltöltése HTTP-n keresztül. Ha a HTTP státusz kód értéke nem 200, akkor a függvény visszatérési érteke XSR_FUNCTION_FAILED.
Bemeneti paraméter. A feltöltéséhez szükséges paramétereket tartalmazó struktúrára mutató pointer.
typedef struct send_data {
XS_ULONG structSize;
XS_IO_DATA_PTR pIn;
XS_CHAR_PTR pURL;
XS_CHAR_PTR pName;
XS_CHAR_PTR pFilename;
XS_IO_DATA_PTR pOut;
} XS_SEND_DATA, XS_PTR XS_SEND_DATA_PTR;
A paraméterben megadott hasht aláírja. Az aláíráshoz be kell állítani a megbízható tanúsítványok könyvtárát és az aláírói tanúsítványt.
Bemeneti és kimeneti paraméter. Az aláíratlan hash-t tartalmazza és ide teszi vissza az aláírt hash-t is a program. Az aláíráshoz szükséges paramétereket tartalmazó struktúrára mutató pointer.
typedef struct sign_hash_data {
XS_ULONG structSize;
XS_IO_DATA_PTR pUnsignedHash;
XS_IO_DATA_PTR pSignedHash;
} XS_SIGN_HASH_DATA, XS_PTR XS_SIGN_HASH_DATA_PTR;
Ellenőrzi a megadott tanúsítvány érvényességét, és a visszavonásra vonatkozó adatokat szolgáltat. Visszavonási információt nemcsak a paraméterben megadott tanúsítványról kapunk, hanem a hozzátartozó tanúsítvány láncban szereplő tanúsítványokról is, illetve ocsp ellenőrzést használva az ocsp választ aláíró tanúsítványról is.
Bemeneti paraméter. A tanúsítvány ellenőrzéséhez szükséges adatokat tartalmazó struktúrára (ld. alább) mutató pointer.
typedef struct validate_certificate_data {
XS_ULONG structSize;
XS_BUFFER_PTR pBuf;
XS_REVOCATION_SUMMARY_DATA_PTR_PTR pRevocationSummaryArray;
XS_ULONG revocationSummaryArraySize;
} XS_VALIDATE_CERTIFICATE_DATA, XS_PTR XS_VALIDATE_CERTIFICATE_DATA_PTR;
typedef struct buffer_struct
{
XS_BYTE_PTR pBuffer;
XS_ULONG bufferLength;
} XS_BUFFER, XS_PTR XS_BUFFER_PTR;
Ahol pBuffer a bájtsorozat kezdőcíme, a bufferLength pedig a hossza.
typedef struct revocation_summary_struct
{
XS_ULONG structSize;
XS_CHAR_PTR certFingerPrint;
XS_ULONG revocationStatus;
XS_ULONG revocationReason;
XS_CHAR_PTR revocationDate;
} XS_REVOCATION_SUMMARY_DATA, XS_PTR XS_REVOCATION_SUMMARY_DATA_PTR;
Fő funkciója egy újabb dokumentum időbélyeg PDF-be illesztése. Amennyiben a PDF már tartalmaz aláírásokat, úgy az összeset leellenőrzi az időbélyegzés előtt. Figyelem! A függvény akkor is elhelyez egy időbélyeget a PDF-en, ha nincs aláírva! Amennyiben a dokumentum tartalmaz adbe.x509.rsa_sha1 SubFilter értékű aláírásokat, akkor a PAdES-LTV szintű aláírás nem támogatott.
Bemeneti paraméter. A PDF dokumentum handle-je, melyhez az időbélyeget szeretnénk hozzáadni.
Bemeneti paraméter. Az időbélyeg hozzáadásának paramétereit tartalmazó struktúra.
typedef struct add_timestamp_pdf_struct
{
XS_ULONG structSize;
XS_BOOL bUnknownSubfilterFlags;
} XS_PDF_ADD_TIMESTAMP_DATA, XS_PTR XS_PDF_ADD_TIMESTAMP_DATA_PTR;
PDF fájlba csatolt dokumentum beillesztése.
Bemeneti paraméter. A PDF dokumentum handle-je, melyhez az időbélyeget szeretnénk hozzáadni.
Bemeneti paraméter. A csatolmány hozzáadásának paramétereit tartalmazó struktúra.
typedef struct add_attachment_pdf_struct
{
XS_ULONG structSize;
XS_CHAR_PTR pDescription;
XS_IO_DATA XS_PTR pInput;
} XS_ADD_PDF_ATTACHMENT_DATA, XS_PTR XS_ADD_PDF_ATTACHMENT_DATA_PTR;
Saját metaadat hozzáadása a PDF dokumentumhoz.
Bemeneti paraméter. A PDF dokumentum handle-je.
Bemeneti paraméter. A metaadatokat tartalmazó struktúra:
typedef struct add_metadata_pdf_struct
{
XS_ULONG structSize;
XS_MAP_PTR pMetadataMap;
} XS_ADD_PDF_METADATA_DATA, XS_PTR XS_ADD_PDF_METADATA_DATA_PTR;
Létrehoz egy új üres ASiC konténert. A létrejövő konténer használat után felszabadítható az XS_ASiC_FreeContainer függvénnyel.
Kimeneti paraméter. A létrehozott konténerhez tartozó handle-re mutató pointer.
typedef XS_HANDLE XS_ASIC_CONTAINER_HANDLE; typedef XS_ASIC_CONTAINER_HANDLE XS_PTR XS_ASIC_CONTAINER_HANDLE_PTR;
Felszabadítja a korábban létrehozott vagy megnyitott ASiC konténert. A felszabadítás után a konténerhez tartozó handle invaliddá válik.
Be- és kimeneti paraméter. A felszabadítani kívánt konténerhez tartozó handle-re mutató pointer.
typedef XS_ASIC_CONTAINER_HANDLE XS_PTR XS_ASIC_CONTAINER_HANDLE_PTR;
A korábban létrehozott vagy megnyitott ASiC konténert menti el a fájlrendszerbe vagy a memóriába.
Bemeneti paraméter. A menteni kívánt konténerhez tartozó handle.
Bemeneti paraméter. A mentéshez tartozó paramétereket tartalmazó struktúrára mutató pointer, és memóriába történő mentés esetén a pufferre mutató pointer.
typedef XS_IO_DATA XS_SAVE_ASIC_CONTAINER_DATA, XS_PTR XS_SAVE_ASIC_CONTAINER_DATA_PTR;
Az XS_IO_DATA típusú struktúra leírását lásd az XS_SignPDF() függvény dokumentációjánál.
Megnyit egy ASiC konténert a fájlrendszerből vagy a memóriából. A létrejövő konténer használat után felszabadítható az XS_ASiC_FreeContainer függvénnyel.
Bemeneti paraméter. A megnyitáshoz tartozó paramétereket tartalmazó struktúrára mutató pointer.
typedef struct asic_open_struct
{
XS_ULONG structSize;
XS_CHAR_PTR pFilePath;
XS_BUFFER_PTR pBuffer;
XS_ULONG docSizeLimit;
} XS_OPEN_ASIC_CONTAINER_DATA, XS_PTR XS_OPEN_ASIC_CONTAINER_DATA_PTR;
A pFilePath és pBuffer tagmezők kölcsönösen kizárják egymást. Ha az egyik meg van adva, akkor a másik értékét NULL-ra kell állítani. A docSizeLimit-nek csak pFilePath megadása esetén van hatása (viszont később az XSI_ASIC_CONTAINER_DOC_SIZE_LIMIT beállításával bármikor módosítható a program működése).
Kimeneti paraméter. A megnyitott konténerhez tartozó handle-re mutató pointer.
typedef XS_HANDLE XS_ASIC_CONTAINER_HANDLE; typedef XS_ASIC_CONTAINER_HANDLE XS_PTR XS_ASIC_CONTAINER_HANDLE_PTR;
Létező ASiC konténerbe dokumentumot illeszt be.
Bemeneti paraméter. A konténerhez tartozó handle, amibe a dokumentumot be szeretnénk illeszteni.
typedef XS_HANDLE XS_ASIC_CONTAINER_HANDLE;
Bemeneti paraméter. A beillesztéshez szükséges adatokat tartalmazó struktúrára mutató pointer.
typedef struct asic_insert_document_struct
{
XS_ULONG structSize;
XS_CHAR_PTR pFilePath;
XS_BUFFER_PTR pBuffer;
XS_CHAR_PTR pURI;
} XS_ASIC_INSERT_DOCUMENT_DATA, XS_PTR XS_ASIC_INSERT_DOCUMENT_DATA_PTR;
A pFilePath és pBuffer tagmezők kölcsönösen kizárják egymást. Ha az egyik meg van adva, akkor a másik értékét NULL-ra kell állítani.
Kimeneti paraméter. A beillesztett dokumentumot hivatkozó handle-re mutató pointer. Később ezzel a handle-val hivatkozhatunk a dokumentumra a konténeren belül.
typedef XS_HANDLE XS_ASIC_DOCUMENT_HANDLE; typedef XS_ASIC_DOCUMENT_HANDLE XS_PTR XS_ASIC_DOCUMENT_HANDLE_PTR;
Dokumentumot exportál ASiC konténerből.
Bemeneti paraméter. A dokumentumhoz tartozó handle, amit ki szeretnénk exportálni.
typedef XS_HANDLE XS_ASIC_DOCUMENT_HANDLE;
Bemeneti paraméter. Az exportáláshoz szükséges adatokat tartalmazó struktúrára mutató pointer.
typedef XS_IO_DATA XS_ASIC_EXPORT_DOCUMENT_DATA, XS_PTR XS_ASIC_EXPORT_DOCUMENT_DATA_PTR;
Az XS_IO_DATA típusú struktúra leírását lásd az XS_SignPDF() függvény dokumentációjánál.
Dokumentumot töröl ASiC konténerből. A törlés művelet nem hajtható végre, ha létezik legalább egy olyan aláírás az ASiC konténerben, ami a dokumentumot aláírja. Ekkor a függvény visszatérési értéke XSR_INVALID_OPERATION lesz.
Bemeneti paraméter. A dokumentumhoz tartozó handle, amit ki szeretnénk törölni.
typedef XS_HANDLE XS_ASIC_DOCUMENT_HANDLE;
Visszaadja az összes dokumentum handle-jet, ami az ASiC konténerben található.
Bemeneti paraméter. A konténerhez tartozó handle, amiben a dokumentumok találhatóak.
typedef XS_HANDLE XS_ASIC_CONTAINER_HANDLE;
Kimeneti paraméter. A konténerben található dokumentumok handle-jeit tartalmazó tömb.
Az XS_HANDLE_ARRAY definícióját lásd az XS_GetInformation függvény leírásán belül az XSI_COUNTER_SIGNED_SIGNATURES résznél.
Visszaadja az összes aláírás handle-jet, ami az ASiC konténerben található.
Bemeneti paraméter. A konténerhez tartozó handle, amiben az aláírások találhatóak.
typedef XS_HANDLE XS_ASIC_CONTAINER_HANDLE;
Kimeneti paraméter. A konténerben található aláírások handle-jeit tartalmazó tömb.
Az XS_HANDLE_ARRAY definícióját lásd az XS_GetInformation függvény leírásán belül az XSI_COUNTER_SIGNED_SIGNATURES résznél.
Visszaadja az összes aláírás handle-jet, ami a megadott dokumentumot aláírja.
Bemeneti paraméter. Azon dokumentumhoz tartozó handle, amelyik aláírásait kérjük.
typedef XS_HANDLE XS_ASIC_DOCUMENT_HANDLE;
Kimeneti paraméter. A dokumentumot aláíró aláírások handle-jeit tartalmazó tömb.
Az XS_HANDLE_ARRAY definícióját lásd az XS_GetInformation függvény leírásán belül az XSI_COUNTER_SIGNED_SIGNATURES résznél.
Visszaadja az összes dokumentum handle-jet, amit a megadott aláírás aláír.
Bemeneti paraméter. Azon aláíráshoz tartozó handle, amelyik aláírja a visszaadott dokumentumokat.
typedef XS_HANDLE XS_ASIC_SIGNATURE_HANDLE;
Kimeneti paraméter. Az aláírás által aláírt dokumentumok handle-jeit tartalmazó tömb.
Az XS_HANDLE_ARRAY definícióját lásd az XS_GetInformation függvény leírásán belül az XSI_COUNTER_SIGNED_SIGNATURES résznél.
Aláírja a megadott dokumentumokat. Ha a konténer altípusa ismeretlen, akkor lehetőségünk van megadni, hogy XAdES vagy CAdES aláírásokat tartalmazzon. A konténer altípusa akkor lehet ismeretlen, ha még egyetlen aláírást sem tartalmaz.
Bemeneti paraméter. Az aláírni kívánt dokumentumok handle-jeit tartalmazó tömb.
Az XS_HANDLE_ARRAY definícióját lásd az XS_GetInformation függvény leírásán belül az XSI_COUNTER_SIGNED_SIGNATURES résznél.
Bemeneti paraméter. Az aláíráshoz szükséges adatokat tartalmazó struktúra.
typedef struct asic_sign_data_struct
{
XS_ULONG structSize;
XS_CHAR_PTR pSignatureName;
XS_ULONG signatureType;
XS_SIGN_PROPERTIES_PTR pSignProperties;
} XS_ASIC_SIGN_DATA, XS_PTR XS_ASIC_SIGN_DATA_PTR;
Kimeneti paraméter. Az aláírást hivatkozó handlera mutató pointer.
typedef XS_HANDLE XS_ASIC_SIGNATURE_HANDLE; typedef XS_ASIC_SIGNATURE_HANDLE XS_PTR XS_ASIC_SIGNATURE_HANDLE_PTR;
Kétmenetes aláírás létrehozásakor visszaadja azon aláírásokat, amelyek csak az aláírás keret aláíratlan lenyomatát tartalmazzák.
Bemeneti paraméter. A konténerhez tartozó handle, amiben az aláírások találhatóak.
typedef XS_HANDLE XS_ASIC_CONTAINER_HANDLE;
Kimeneti paraméter. A konténerben található aláírások handle-jeit tartalmazó tömb.
Az XS_HANDLE_ARRAY definícióját lásd az XS_GetInformation függvény leírásán belül az XSI_COUNTER_SIGNED_SIGNATURES résznél.
Kétmenetes aláírás létrehozásakor visszaadja az aláírás keret elkészítése (XS_ASiC_Sign() hívás) után az aláíratlan lenyomatot base64 kódolt formában.
Bemeneti paraméter. Azon aláíráshoz tartozó handle, amelyik az aláíratlan lenyomatot tartalmazza.
typedef XS_HANDLE XS_ASIC_SIGNATURE_HANDLE;
Kimeneti paraméter. Az aláíratlan lenyomat lekérésével kapcsolatos adatokat tartalmazó struktúrára mutató pointer.
typedef struct asic_get_unsigned_hash_struct
{
XS_ULONG structSize;
XS_CHAR_PTR pHashValue;
} XS_ASIC_GET_UNSIGNED_HASH_DATA, XS_PTR XS_ASIC_GET_UNSIGNED_HASH_DATA_PTR;
Kétmenetes aláírás létrehozásakor beállítja az aláírt lenyomat értékét a félkész aláírásban. A folyamat befejezése képpen az elkészült aláírás ellenőrzésre kerül, tehát a vonatkozó beállítások (megbízható tanúsítványok, visszavonás-ellenőrzés) szükségesek.
Bemeneti paraméter. Azon aláíráshoz tartozó handle, amelyik aláírt lenyomatát be szeretnénk állítani.
typedef XS_HANDLE XS_ASIC_SIGNATURE_HANDLE;
Bemeneti paraméter. Az aláírt lenyomat beállításával kapcsolatos adatokat tartalmazó struktúrára mutató pointer.
typedef struct asic_set_signed_hash_struct
{
XS_ULONG structSize;
XS_CHAR_PTR pHashValue;
XS_ULONG addTimeStamp;
} XS_ASIC_SET_SIGNED_HASH_DATA, XS_PTR XS_ASIC_SET_SIGNED_HASH_DATA_PTR;
Ellenőrzi a megadott aláírást. Ha az aláírás helyességét a függvény a visszatérési értékében jelzi. Lásd: visszatérési értékek.
Bemeneti paraméter. Azon aláíráshoz tartozó handle, amelyiket ellenőrizni szeretnénk.
typedef XS_HANDLE XS_ASIC_SIGNATURE_HANDLE;
Bemeneti paraméter. Az ellenőrzéssel kapcsolatos adatokat tartalmazó struktúrára mutató pointer. Jelenleg nem használjuk. Értéke mindig NULL.
Eltávolítja a megadott aláírást az ASiC konténerből.
Bemeneti paraméter. Azon aláíráshoz tartozó handle, amelyiket el szeretnénk távolítani.
typedef XS_HANDLE XS_ASIC_SIGNATURE_HANDLE;
Új ESign munkamenet indítása. Jelenleg a parancs segítségével egy dokumentum kétmenetes aláírásához lehet munkamenetet indítani. Használat előtt szükséges lehet az ESign központi szerverrel való biztonságos kommunikációhoz szükséges egyéb paraméterek (pl. authentikációs adatok) beállítása is.
Bemeneti paraméter. A központi szerver URL-je, amelyhez a munkamenet indítási kérelmet intézzük.
Bemeneti paraméter. Az aláírandó dokumentum elérési útja.
typedef struct esign_document_param
{
XS_ULONG structSize;
XS_ULONG documentCount;
XS_ESIGN_DOCUMENT_PTR documentElements;
} XS_ESIGN_DOCUMENT_LIST, XS_PTR XS_ESIGN_DOCUMENT_LIST_PTR;
Kimeneti paraméter. A létrehozott munkamenet paraméterei (pl. sessionID) JSON formátumban.
typedef XS_CHAR_PTR_PTR XS_SESSION_PARAMS_JSON_PTR;
Bemeneti paraméter. Az eSign munkamenet személyreszabása végezhető el e paraméter segítségével .
typedef struct custom_esign_params
{
XS_ULONG structSize;
XS_CHAR_PTR customSPName;
XS_CHAR_PTR customMessage;
XS_CHAR_PTR customURIScheme;
XS_CHAR_PTR customFilters;
XS_BOOL documentStateProvided;
} XS_CUSTOM_ESIGN_PARAMS, XS_PTR XS_CUSTOM_ESIGN_PARAMS_PTR;
A mobil alíráshoz szükséges QR kódot adja vissza.
Bemeneti paraméter. A létrehozott munkamenet paraméterei (pl. sessionID) JSON formátumban.
typedef XS_CHAR_PTR_PTR XS_SESSION_PARAMS_JSON_PTR;
Bemeneti paraméter. opcionálisan megadható URI séma. Alapértelmezett értéke: "esign"
typedef XS_CHAR_PTR_PTR XS_SESSION_PARAMS_JSON_PTR;
Ki- és bemeneti paraméter. Az ESign URI-t és az abból készített QR kódot tartalmazza.
typedef struct qr {
XS_ULONG structSize;
XS_BUFFER buffer;
XS_ULONG type;
XS_BUFFER esignURI;
} XS_QR_BUFFER, XS_PTR XS_QR_BUFFER_PTR;
ESign munkamenet törlése. Erre akkor lehet szükség például, ha a kétmenetes aláírás első fázisához lejárt tanúsítványt kaptunk az aláíró klienstől.
Bemeneti paraméter. A munkamenet indításakor létrehozott, a munkamenet paramétereit tartalmazó JSON.
typedef XS_CHAR_PTR_PTR XS_SESSION_PARAMS_JSON_PTR;
Tanúsítvány lekérése az ESign központi szervertől. Előbbi a kétmenetes aláírás első feléhez szükséges.
Bemeneti paraméter. A munkamenet indításakor létrehozott, a munkamenet paramétereit tartalmazó JSON.
typedef XS_CHAR_PTR_PTR XS_SESSION_PARAMS_JSON_PTR;
Kimeneti paraméter. A lekérés során visszakapott adatot tartalmazza. Az XS_BUFFER struktúra definícióját lásd az XS_OpenDossier függvény leírásánál.
Bemeneti paraméter. A lekéréshez szükséges információkat tartalmazza. Értéke egy XS_POLL_CERT típusú struktúrára mutató pointer
typedef struct poll_cert {
XS_ULONG structSize;
XS_CHAR_PTR certUrl;
}XS_POLL_CERT, XS_PTR XS_POLL_CERT_PTR;
Bemeneti paraméter. Lekérés időzítési paraméterei.
typedef struct poll_options {
XS_ULONG structSize;
XS_ULONG pollDelay;
XS_DOUBLE pollTimeout;
} XS_ESIGN_POLL_OPTIONS, XS_PTR XS_ESIGN_POLL_OPTIONS_PTR;
Aláírt hash lekérése az ESign központi szervertől. A kétmenetes aláírás második feléhez szükséges. Aláírt hash lekérése esetén ugyanezen parancson belül megtörténik az aláíratlan hash felküldése (ezt írja majd alá a kliens).
Bemeneti paraméter. A munkamenet indításakor létrehozott, a munkamenet paramétereit tartalmazó JSON.
typedef XS_CHAR_PTR_PTR XS_SESSION_PARAMS_JSON_PTR;
Kimeneti paraméter. A lekérés során visszakapott adatot tartalmazza.
typedef struct esign_hash_list
{
XS_ULONG structSize;
XS_ULONG count;
XS_ESIGN_DOCUMENT_HASH_PTR esignDocumentHash;
} XS_ESIGN_DOCUMENT_HASH_LIST, XS_PTR XS_ESIGN_DOCUMENT_HASH_LIST_PTR;
typedef struct esign_hash
{
XS_ULONG structSize;
XS_CHAR_PTR hash;
} XS_ESIGN_DOCUMENT_HASH, XS_PTR XS_ESIGN_DOCUMENT_HASH_PTR;
Bemeneti paraméter. A lekéréshez szükséges információkat tartalmazza. Értéke egy XS_POLL_SIGNED típusú struktúrára mutató pointer:
typedef struct poll_signed {
XS_ULONG structSize;
XS_CHAR_PTR unsignedHashUrl;
XS_CHAR_PTR signedHashUrl;
XS_ESIGN_DOCUMENT_HASH_LIST_PTR unsignedHashes;
XS_BOOL usePKCS7;
} XS_POLL_SIGNED, XS_PTR XS_POLL_SIGNED_PTR;
Bemeneti paraméter. Lekérés időzítési paraméterei.
typedef struct poll_options {
XS_ULONG structSize;
XS_ULONG pollDelay;
XS_DOUBLE pollTimeout;
} XS_ESIGN_POLL_OPTIONS, XS_PTR XS_ESIGN_POLL_OPTIONS_PTR;
A dokumentumok állapotának közvetítő szerver felé történő megadását szolgáló függvény. Az állapotok megadásával lehet jelezni a közvetítő szervernek, hogy sikerült-e az aláírás, vagy esetleg valami hiba történt.
Bemeneti paraméter. A munkamenet indításakor létrehozott, a munkamenet paramétereit tartalmazó JSON.
typedef XS_CHAR_PTR_PTR XS_SESSION_PARAMS_JSON_PTR;
Bemeneti paraméter. ESign központi szerver dokumentumok állapotának beállításához tartozó URL-je.
Bemeneti paraméter. Az állapotok küldéséhez szükséges információkat tartalmazza. Értéke egy XS_ESIGN_DOCUMENT_STATE_LIST típusú struktúrára mutató pointer
typedef struct esign_doc_state_list
{
XS_ULONG structSize;
XS_ULONG documentCount;
XS_ESIGN_DOCUMENT_STATE_PTR documentElements;
} XS_ESIGN_DOCUMENT_STATE_LIST, XS_PTR XS_ESIGN_DOCUMENT_STATE_LIST_PTR;
typedef struct esign_doc_state
{
XS_ULONG structSize;
XS_CHAR_PTR docState;
XS_CHAR_PTR docStateComment;
} XS_ESIGN_DOCUMENT_STATE, XS_PTR XS_ESIGN_DOCUMENT_STATE_PTR;
XS_RV test()
{
int rc = 0;
HMODULE hDll = NULL;
t_pfnXS_GetFunctionList pEntry = NULL;
XS_RV xsRC = XSR_OK;
int initted = 0;
XS_INITIALIZE_DATA init_data;
hDll = LoadLibrary("xsign.dll");
if (!hDll)
{
goto end;
}
/* getting main entry point */
pEntry = (t_pfnXS_GetFunctionList)GetProcAddress(hDll, "XS_GetFunctionList");
if (!pEntry)
{
fprintf(stderr, "error getting XS_GetFunctionList entry point.\n");
goto end;
}
/* getting function list */
xsRC = pEntry(&pXSign);
if (xsRC != XSR_OK)
{
goto end;
}
/* log path */
xsRC = pXSign->XS_SetOption(XSO_LOG_FILE_PATH, "xsign_log.txt");
if (xsRC != XSR_OK)
{
goto end;
}
XS_INSERT_DOCUMENT_DATA idc_data;
XS_RV xsRC = XSR_OK;
XS_DOSSIER_HANDLE hDossier = 0;
XS_SAVE_DOSSIER_DATA sd_data;
/* create a new dossier */
xsRC = pXSign->XS_NewDossier(NULL, &hDossier);
if (xsRC != XSR_OK)
{
goto end;
}
/* inserting a document */
memset(&idc_data, 0, sizeof(idc_data));
idc_data.structSize = sizeof(idc_data);
idc_data.pFilePath = "test.txt";
xsRC = pXSign->XS_InsertDocument(hDossier, &idc_data, NULL);
if (xsRC != XSR_OK)
{
goto end;
}
/* save dossier */
memset(&sd_data, 0, sizeof(sd_data));
sd_data.structSize = sizeof(sd_data);
sd_data.pFilePath = "new.es3";
xsRC = pXSign->XS_SaveDossier(hDossier, &sd_data);
if (xsRC != XSR_OK)
{
goto end;
}
end:
return xsRC;
}
XS_RV test()
{
int rc = 0;
HMODULE hDll = NULL;
t_pfnXS_GetFunctionList pEntry = NULL;
XS_RV xsRC = XSR_OK;
int initted = 0;
XS_INITIALIZE_DATA init_data;
hDll = LoadLibrary("xsign.dll");
if (!hDll)
{
goto end;
}
/* getting main entry point */
pEntry = (t_pfnXS_GetFunctionList)GetProcAddress(hDll, "XS_GetFunctionList");
if (!pEntry)
{
fprintf(stderr, "error getting XS_GetFunctionList entry point.\n");
goto end;
}
/* getting function list */
xsRC = pEntry(&pXSign);
if (xsRC != XSR_OK)
{
goto end;
}
/* log path */
xsRC = pXSign->XS_SetOption(XSO_LOG_FILE_PATH, "xsign_log.txt");
if (xsRC != XSR_OK)
{
goto end;
}
XS_RV xsRC = XSR_OK;
XS_RV xsRC2 = XSR_OK;
XS_OPEN_DOSSIER_DATA od_data;
XS_DOSSIER_HANDLE hDossier = 0;
XS_INITIALIZE_DATA init_data;
XS_SIGNING_CERTIFICATE_DATA scd;
XS_PFX_KEY_DATA pfxd;
int reinitted = 0;
/*******************************/
xsRC = pXSign->XS_Finalize(NULL);
if (xsRC != XSR_OK)
{
goto end;
}
memset(&init_data, 0, sizeof(init_data));
init_data.structSize = sizeof(init_data);
init_data.pWorkDir = ".";
init_data.pRegFilePath = "./test_reg.xml";
xsRC = pXSign->XS_Initialize(&init_data);
if (xsRC != XSR_OK)
{
goto end;
}
reinitted = 1;
xsRC = pXSign->XS_SetOption(XSO_WORK_SILENT,(XS_VOID_PTR)XS_FORCE_SILENT);
if (xsRC != XSR_OK)
{
goto end;
}
/* set pfx key */
memset(&scd, 0, sizeof(scd));
memset(&pfxd, 0, sizeof(pfxd));
pfxd.structSize = sizeof(pfxd);
pfxd.pPath = "./keys/test_alairas.pfx";
pfxd.pPassword = "12345";
scd.structSize = sizeof(scd);
scd.keyType = XS_KEYFORM_PFX;
scd.pData = &pfxd;
xsRC = pXSign->XS_SetOption(XSO_SIGNING_CERTIFICATE, &scd);
if (xsRC != XSR_NOT_REGISTERED)
{
xsRC = XSR_FUNCTION_FAILED;
goto end;
}
/* anyway, keep on trying */
memset(&od_data, 0, sizeof(od_data));
od_data.structSize = sizeof(od_data);
od_data.pFilePath = "./proba.es3";
xsRC = pXSign->XS_OpenDossier(&od_data, &hDossier);
if (xsRC != XSR_OK)
{
goto end;
}
xsRC = pXSign->XS_SignFrame(hDossier, NULL_PTR, NULL_PTR);
if (xsRC != XSR_FUNCTION_FAILED)
{
xsRC = XSR_FUNCTION_FAILED;
goto end;
}
xsRC = pXSign->XS_FreeDossier(NULL_PTR, &hDossier);
if (xsRC != XSR_OK)
{
goto end;
}
end:
if (reinitted)
{
xsRC2 = pXSign->XS_Finalize(NULL);
if (xsRC2 != XSR_OK)
{
goto end_end;
}
memset(&init_data, 0, sizeof(init_data));
init_data.structSize = sizeof(init_data);
init_data.pWorkDir = ".";
xsRC2 = pXSign->XS_Initialize(&init_data);
if (xsRC2 != XSR_OK)
{
goto end_end;
}
}
end_end:
return xsRC;
}
/* step1
char* argv[] = {„app_name”, „app_parameter”, „path_to_jar_files”, „step1”, „sample.pdf”, „half_signed.pdf”};
*/
/* step2
char* argv[] = {„app_name”, „app_parameter”, „path_to_jar_files”, „step2”, „half_signed.pdf”,
„WrfdsgrE465fdGFD...fefdsnklvr7”, „signed.pdf”};
*/
extern XS_FUNCTION_LIST_PTR pXSign;
/* try 2-step pdf signature creation */
XS_RV test(int argc, char* argv[])
{
XS_RV xsRC = XSR_OK;
/*******************************/
if (argc < 4)
return XSR_FUNCTION_FAILED;
xsRC = pXSign->XS_SetOption(XSO_JAR_PATH, (XS_VOID_PTR)argv[2]);
if (xsRC != XSR_OK)
{
fprintf(stderr, "XS_SetOption failed, returned %d\n", xsRC);
goto end;
}
xsRC = pXSign->XS_SetOption(XSO_WIN_USE_CERT_STORE, (XS_VOID_PTR)XS_FALSE);
if (xsRC != XSR_OK)
{
fprintf(stderr, "XS_SetOption failed, returned %d\n", xsRC);
goto end;
}
xsRC = pXSign->XS_SetOption(XSO_TRUSTED_CERT_DIR, (XS_VOID_PTR)"test_files/trusted_certs");
if (xsRC != XSR_OK)
{
fprintf(stderr, "XS_SetOption failed, returned %d\n", xsRC);
goto end;
}
xsRC = pXSign->XS_SetOption(XSO_INTERMEDIATE_CERT_DIR, (XS_VOID_PTR)"test_files/intermediate_certs");
if (xsRC != XSR_OK)
{
fprintf(stderr, "XS_SetOption failed, returned %d\n", xsRC);
goto end;
}
if (strcmp(argv[3], "step1") == 0)
{
XS_SIGNING_CERTIFICATE_DATA scd;
XS_CERT_KEY_DATA ckd;
XS_OPEN_PDF_DOCUMENT_DATA opdfdd;
XS_PDF_DOCUMENT_HANDLE hpdfdoc;
XS_SIGN_PDF_DOCUMENT_DATA signpdfdd;
XS_PDF_SIGNATURE_HANDLE hpdfsig;
XS_GET_UNSIGNED_HASH_PDF_SIGNATURE_DATA guhpdfsd;
XS_SAVE_PDF_DOCUMENT_DATA savepdfdd;
char *pUnsignedPDF;
char *pHalfSignedPDF;
char *pUnsignedHash;
/********************************************/
if (argc < 6)
return XSR_FUNCTION_FAILED;
pUnsignedPDF = argv[4];
pHalfSignedPDF = argv[5];
xsRC = pXSign->XS_SetOption(XSO_WORK_SILENT, (XS_VOID_PTR)XS_FORCE_SILENT);
if (xsRC != XSR_OK)
{
fprintf(stderr, "XS_SetOption failed, returned %d\n", xsRC);
goto end;
}
memset(&scd, 0, sizeof(scd));
scd.structSize = sizeof(scd);
scd.keyType = XS_KEYFORM_CERT;
memset(&ckd, 0, sizeof(ckd));
ckd.structSize = sizeof(ckd);
ckd.pPath = "test_files/func_000018.cer";
scd.pData = &ckd;
xsRC = pXSign->XS_SetOption(XSO_SIGNING_CERTIFICATE, &scd);
if (xsRC != XSR_OK)
{
fprintf(stderr, "XS_SetOption failed, returned %d\n", xsRC);
goto end;
}
memset(&opdfdd, 0, sizeof(opdfdd));
opdfdd.structSize = sizeof(opdfdd);
opdfdd.pFilePath = pUnsignedPDF;
xsRC = pXSign->XS_OpenPDFDocument(&opdfdd, &hpdfdoc);
if (xsRC != XSR_OK)
{
fprintf(stderr, "XS_OpenPDFDocument failed, returned %d\n", xsRC);
goto end;
}
memset(&signpdfdd, 0, sizeof(signpdfdd));
signpdfdd.structSize = sizeof(signpdfdd);
signpdfdd.preserveSize = 16*1024;
xsRC = pXSign->XS_SignPDFDocument(hpdfdoc, &signpdfdd, &hpdfsig);
if (xsRC != XSR_OK)
{
fprintf(stderr, "XS_SignPDFDocument failed, returned %d\n", xsRC);
goto end;
}
memset(&guhpdfsd, 0, sizeof(guhpdfsd));
guhpdfsd.structSize = sizeof(guhpdfsd);
guhpdfsd.ppBASE64EncodedUnsignedHash = &pUnsignedHash;
xsRC = pXSign->XS_GetUnsignedHashPDFSignature(hpdfsig, &guhpdfsd);
if (xsRC != XSR_OK)
{
fprintf(stderr, "XS_GetUnsignedHashPDFSignature failed, returned %d\n", xsRC);
goto end;
}
memset(&savepdfdd, 0, sizeof(savepdfdd));
savepdfdd.structSize = sizeof(savepdfdd);
savepdfdd.pFilePath = pHalfSignedPDF;
xsRC = pXSign->XS_SavePDFDocument(hpdfdoc, &savepdfdd);
if (xsRC != XSR_OK)
{
fprintf(stderr, "XS_SavePDFDocument failed, returned %d\n", xsRC);
goto end;
}
xsRC = pXSign->XS_FreePDFDocument(NULL, &hpdfdoc);
if (xsRC != XSR_OK)
{
fprintf(stderr, "XS_FreePDFDocument failed, returned %d\n", xsRC);
goto end;
}
printf("%s", pUnsignedHash);
}
else if (strcmp(argv[3], "step2") == 0)
{
char *pHalfSignedPDF;
char *pSignedHash;
char *pSignedPDF;
XS_OPEN_PDF_DOCUMENT_DATA opdfdd;
XS_PDF_DOCUMENT_HANDLE hpdfdoc;
XS_SET_SIGNED_HASH_PDF_SIGNATURE_DATA sshpdfsd;
XS_HANDLE_ARRAY hpdfsigs;
XS_SAVE_PDF_DOCUMENT_DATA savepdfdd;
/*********************************/
if (argc < 7)
return XSR_FUNCTION_FAILED;
pHalfSignedPDF = argv[4];
pSignedHash = argv[5];
pSignedPDF = argv[6];
xsRC = pXSign->XS_SetOption(XSO_TIMESTAMP_URL_LIST, (XS_VOID_PTR)"http://teszt.e-szigno.hu/tsa");
if (xsRC != XSR_OK)
{
fprintf(stderr, "XS_SetOption failed, returned %d\n", xsRC);
goto end;
}
xsRC = pXSign->XS_SetOption(XSO_SIGNATURE_LEVEL, (XS_VOID_PTR)XS_SIGLEVEL_B_T);
if (xsRC != XSR_OK)
{
fprintf(stderr, "XS_SetOption failed, returned %d\n", xsRC);
goto end;
}
xsRC = pXSign->XS_SetOption(XSO_XADES_VERSION, (XS_VOID_PTR)XS_XADES_VERSION_EN_1_0_0);
if (xsRC != XSR_OK)
{
fprintf(stderr, "XS_SetOption failed, returned %d\n", xsRC);
goto end;
}
memset(&opdfdd, 0, sizeof(opdfdd));
opdfdd.structSize = sizeof(opdfdd);
opdfdd.pFilePath = pHalfSignedPDF;
xsRC = pXSign->XS_OpenPDFDocument(&opdfdd, &hpdfdoc);
if (xsRC != XSR_OK)
{
fprintf(stderr, "XS_OpenPDFDocument failed, returned %d\n", xsRC);
goto end;
}
memset(&hpdfsigs, 0, sizeof(hpdfsigs));
xsRC = pXSign->XS_GetPDFSignatures(hpdfdoc, &hpdfsigs);
if (xsRC != XSR_OK)
{
fprintf(stderr, "XS_GetPDFSignatures failed, returned %d\n", xsRC);
goto end;
}
memset(&sshpdfsd, 0, sizeof(sshpdfsd));
sshpdfsd.structSize = sizeof(sshpdfsd);
sshpdfsd.pBASE64EncodedSignedHash = pSignedHash;
xsRC = pXSign->XS_SetSignedHashPDFSignature(hpdfsigs.phHandles[hpdfsigs.ulCount - 1], &sshpdfsd);
if (xsRC != XSR_OK)
{
fprintf(stderr, "XS_SetSignedHashPDFSignature failed, returned %d\n", xsRC);
goto end;
}
memset(&savepdfdd, 0, sizeof(savepdfdd));
savepdfdd.structSize = sizeof(savepdfdd);
savepdfdd.pFilePath = pSignedPDF;
xsRC = pXSign->XS_SavePDFDocument(hpdfdoc, &savepdfdd);
if (xsRC != XSR_OK)
{
fprintf(stderr, "XS_SavePDFDocument failed, returned %d\n", xsRC);
goto end;
}
xsRC = pXSign->XS_FreePDFDocument(NULL, &hpdfdoc);
if (xsRC != XSR_OK)
{
fprintf(stderr, "XS_FreePDFDocument failed, returned %d\n", xsRC);
goto end;
}
}
xsRC = XSR_OK;
end:
return xsRC;
}