@astratra/wallet 1.1.0 → 1.2.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -0,0 +1,143 @@
1
+ /* Encodage DER (X.690), réduit à ce que demande la signature d'une carte
2
+ Apple Wallet, et un lecteur juste assez grand pour retrouver, dans un
3
+ certificat, son émetteur et son numéro de série. */
4
+
5
+ function longueur(n) {
6
+ if (n < 0x80) return Buffer.from([n]);
7
+ const octets = [];
8
+ for (let reste = n; reste > 0; reste = Math.floor(reste / 256)) octets.unshift(reste % 256);
9
+ return Buffer.from([0x80 | octets.length, ...octets]);
10
+ }
11
+
12
+ /** Un élément complet : étiquette, longueur, contenu. */
13
+ function tlv(etiquette, contenu) {
14
+ return Buffer.concat([Buffer.from([etiquette]), longueur(contenu.length), contenu]);
15
+ }
16
+
17
+ const sequence = (...elements) => tlv(0x30, Buffer.concat(elements));
18
+
19
+ /* DER range les éléments d'un SET OF par ordre croissant de leur encodage,
20
+ le plus court complété par des zéros. */
21
+ function comparerEncodages(a, b) {
22
+ const n = Math.max(a.length, b.length);
23
+ for (let i = 0; i < n; i += 1) {
24
+ const ecart = (a[i] ?? 0) - (b[i] ?? 0);
25
+ if (ecart !== 0) return ecart;
26
+ }
27
+ return 0;
28
+ }
29
+
30
+ const trier = (elements) => [...elements].sort(comparerEncodages);
31
+
32
+ /** SET OF, trié comme l'exige DER. */
33
+ const ensemble = (elements) => tlv(0x31, Buffer.concat(trier(elements)));
34
+
35
+ /** [n] IMPLICIT SET OF : même contenu trié qu'un SET, autre étiquette. */
36
+ const ensembleImplicite = (n, elements) => tlv(0xa0 | n, Buffer.concat(trier(elements)));
37
+
38
+ /** [n] EXPLICIT : enveloppe un élément complet. */
39
+ const explicite = (n, element) => tlv(0xa0 | n, element);
40
+
41
+ /** Entier positif ou nul, assez petit pour un nombre JavaScript. */
42
+ function entier(n) {
43
+ if (!Number.isSafeInteger(n) || n < 0) throw new RangeError(`Entier DER invalide : ${n}`);
44
+ const octets = [];
45
+ for (let reste = n; reste > 0; reste = Math.floor(reste / 256)) octets.unshift(reste % 256);
46
+ if (octets.length === 0 || octets[0] & 0x80) octets.unshift(0);
47
+ return tlv(0x02, Buffer.from(octets));
48
+ }
49
+
50
+ function identifiant(texte) {
51
+ const arcs = texte.split('.').map(Number);
52
+ if (arcs.length < 2 || arcs.some((arc) => !Number.isSafeInteger(arc) || arc < 0)) {
53
+ throw new RangeError(`Identifiant d'objet invalide : ${texte}`);
54
+ }
55
+ const octets = [];
56
+ for (const arc of [arcs[0] * 40 + arcs[1], ...arcs.slice(2)]) {
57
+ const morceaux = [arc % 128];
58
+ for (let reste = Math.floor(arc / 128); reste > 0; reste = Math.floor(reste / 128)) morceaux.unshift(0x80 | (reste % 128));
59
+ octets.push(...morceaux);
60
+ }
61
+ return tlv(0x06, Buffer.from(octets));
62
+ }
63
+
64
+ const nul = () => Buffer.from([0x05, 0x00]);
65
+ const chaineOctets = (contenu) => tlv(0x04, contenu);
66
+
67
+ /* Avant 2050, UTCTime ; ensuite, GeneralizedTime (RFC 5280, 4.1.2.5). */
68
+ function temps(date) {
69
+ if (!(date instanceof Date) || Number.isNaN(date.getTime())) throw new RangeError('Date de signature invalide.');
70
+ const deux = (n) => String(n).padStart(2, '0');
71
+ const annee = date.getUTCFullYear();
72
+ const suite = `${deux(date.getUTCMonth() + 1)}${deux(date.getUTCDate())}${deux(date.getUTCHours())}${deux(date.getUTCMinutes())}${deux(date.getUTCSeconds())}Z`;
73
+ if (annee >= 1950 && annee < 2050) return tlv(0x17, Buffer.from(`${deux(annee % 100)}${suite}`, 'ascii'));
74
+ return tlv(0x18, Buffer.from(`${String(annee).padStart(4, '0')}${suite}`, 'ascii'));
75
+ }
76
+
77
+ /** Lit l'élément qui commence à `debut`. Refuse les longueurs indéfinies (interdites en DER) et ce qui déborde. */
78
+ function lire(buffer, debut = 0) {
79
+ if (debut + 2 > buffer.length) throw new RangeError('DER tronqué.');
80
+ const etiquette = buffer[debut];
81
+ if ((etiquette & 0x1f) === 0x1f) throw new RangeError('Étiquette DER longue non prise en charge.');
82
+ let position = debut + 1;
83
+ let taille = buffer[position];
84
+ position += 1;
85
+ if (taille & 0x80) {
86
+ const nombre = taille & 0x7f;
87
+ if (nombre === 0 || nombre > 4) throw new RangeError('Longueur DER invalide.');
88
+ if (position + nombre > buffer.length) throw new RangeError('DER tronqué.');
89
+ taille = 0;
90
+ for (let i = 0; i < nombre; i += 1) taille = taille * 256 + buffer[position + i];
91
+ position += nombre;
92
+ }
93
+ const fin = position + taille;
94
+ if (fin > buffer.length) throw new RangeError('DER tronqué.');
95
+ return { etiquette, debut, contenu: position, fin };
96
+ }
97
+
98
+ /** Les éléments contenus dans un élément construit. */
99
+ function enfants(buffer, element) {
100
+ const liste = [];
101
+ for (let position = element.contenu; position < element.fin;) {
102
+ const enfant = lire(buffer, position);
103
+ liste.push(enfant);
104
+ position = enfant.fin;
105
+ }
106
+ return liste;
107
+ }
108
+
109
+ const brut = (buffer, element) => buffer.subarray(element.debut, element.fin);
110
+
111
+ /**
112
+ * L'émetteur et le numéro de série d'un certificat X.509 (DER), tels quels :
113
+ * c'est par eux que la signature désigne son signataire.
114
+ */
115
+ function emetteurEtNumero(certificat) {
116
+ const racine = lire(certificat);
117
+ if (racine.etiquette !== 0x30 || racine.fin !== certificat.length) throw new RangeError('Certificat DER invalide.');
118
+ const [corps] = enfants(certificat, racine);
119
+ if (!corps || corps.etiquette !== 0x30) throw new RangeError('Certificat DER invalide.');
120
+ const champs = enfants(certificat, corps);
121
+ const decalage = champs[0]?.etiquette === 0xa0 ? 1 : 0;
122
+ const numero = champs[decalage];
123
+ const emetteur = champs[decalage + 2];
124
+ if (numero?.etiquette !== 0x02 || emetteur?.etiquette !== 0x30) throw new RangeError('Certificat DER invalide.');
125
+ return { emetteur: brut(certificat, emetteur), numero: brut(certificat, numero) };
126
+ }
127
+
128
+ module.exports = {
129
+ tlv,
130
+ sequence,
131
+ ensemble,
132
+ ensembleImplicite,
133
+ explicite,
134
+ entier,
135
+ identifiant,
136
+ nul,
137
+ chaineOctets,
138
+ temps,
139
+ lire,
140
+ enfants,
141
+ brut,
142
+ emetteurEtNumero
143
+ };
@@ -0,0 +1,244 @@
1
+ /* Les clés de premier niveau du pass.json qui ne sont ni l'identité de la
2
+ carte, ni son style, ni ses champs : dates, lieux, billets groupés, données
3
+ des billets en affiche, liens du guide de l'événement… Chacune est contrôlée
4
+ selon la documentation d'Apple (WalletPasses, « Pass »), puis écrite telle
5
+ quelle. Une clé qu'Apple ajoutera plus tard passe par extraKeys, sans
6
+ attendre une nouvelle version du paquet. */
7
+
8
+ function refus(message) {
9
+ return new TypeError(`Carte Apple Wallet : ${message}`);
10
+ }
11
+
12
+ const texteNonVide = (valeur) => typeof valeur === 'string' && valeur.trim().length > 0;
13
+ const objetSimple = (valeur) => valeur !== null && typeof valeur === 'object' && !Array.isArray(valeur)
14
+ && !(valeur instanceof Date) && !(valeur instanceof Uint8Array);
15
+
16
+ /* Date W3C avec l'heure et le fuseau, comme l'exige Apple ; le fuseau peut
17
+ s'écrire -7:00 (exemple de la documentation). */
18
+ const DATE_W3C = /^\d{4}-(0[1-9]|1[0-2])-(0[1-9]|[12]\d|3[01])T([01]\d|2[0-3]):[0-5]\d(:[0-5]\d(\.\d+)?)?(Z|[+-]\d{1,2}(:?[0-5]\d)?)$/;
19
+ const EXEMPLE_DATE = '2026-12-31T20:30+01:00';
20
+ const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
21
+ const RGB = /^rgb\(\s*(\d{1,3})\s*,\s*(\d{1,3})\s*,\s*(\d{1,3})\s*\)$/;
22
+
23
+ function date(nom, valeur) {
24
+ if (valeur instanceof Date) {
25
+ if (Number.isNaN(valeur.getTime())) throw refus(`${nom} est une date invalide.`);
26
+ return valeur.toISOString();
27
+ }
28
+ if (typeof valeur === 'string' && DATE_W3C.test(valeur)) return valeur;
29
+ throw refus(`${nom} doit être une Date ou un texte ISO 8601 avec l'heure et le fuseau (par exemple ${EXEMPLE_DATE}) ; reçu « ${valeur} ».`);
30
+ }
31
+
32
+ /* Les dates d'un objet libre (semantics, userInfo, extraKeys) deviennent du
33
+ texte ISO ; ce qui ne survivrait pas au JSON est refusé plutôt que perdu. */
34
+ function jsonSur(nom, valeur) {
35
+ if (valeur instanceof Date) return date(nom, valeur);
36
+ if (valeur === null || typeof valeur === 'string' || typeof valeur === 'boolean') return valeur;
37
+ if (typeof valeur === 'number') {
38
+ if (!Number.isFinite(valeur)) throw refus(`${nom} contient un nombre invalide (${valeur}).`);
39
+ return valeur;
40
+ }
41
+ if (Array.isArray(valeur)) return valeur.map((element, i) => jsonSur(`${nom}[${i}]`, element));
42
+ if (objetSimple(valeur)) {
43
+ const resultat = {};
44
+ for (const [cle, element] of Object.entries(valeur)) {
45
+ if (element !== undefined) resultat[cle] = jsonSur(`${nom}.${cle}`, element);
46
+ }
47
+ return resultat;
48
+ }
49
+ throw refus(`${nom} contient une valeur qui ne s'écrit pas en JSON (${typeof valeur}).`);
50
+ }
51
+
52
+ function texte(nom, valeur) {
53
+ if (!texteNonVide(valeur)) throw refus(`${nom} doit être un texte non vide.`);
54
+ return valeur;
55
+ }
56
+
57
+ function booleen(nom, valeur) {
58
+ if (typeof valeur !== 'boolean') throw refus(`${nom} doit valoir true ou false.`);
59
+ return valeur;
60
+ }
61
+
62
+ function adresse(nom, valeur) {
63
+ let lue;
64
+ try {
65
+ lue = new URL(valeur);
66
+ } catch {
67
+ throw refus(`${nom} n'est pas une adresse : « ${valeur} ».`);
68
+ }
69
+ if (!['https:', 'http:'].includes(lue.protocol)) throw refus(`${nom} doit commencer par https://.`);
70
+ return valeur;
71
+ }
72
+
73
+ function couleur(nom, valeur) {
74
+ const morceaux = RGB.exec(String(valeur));
75
+ if (!morceaux || morceaux.slice(1).some((n) => Number(n) > 255)) {
76
+ throw refus(`la couleur ${nom} s'écrit rgb(r, g, b), chaque valeur de 0 à 255 ; reçu « ${valeur} ».`);
77
+ }
78
+ return valeur;
79
+ }
80
+
81
+ function nombre(nom, valeur, { min = -Infinity, max = Infinity, entier = false, strict = false } = {}) {
82
+ const ok = typeof valeur === 'number' && Number.isFinite(valeur) && (!entier || Number.isInteger(valeur))
83
+ && (strict ? valeur > min : valeur >= min) && valeur <= max;
84
+ if (!ok) {
85
+ const borne = strict ? `plus grand que ${min}` : `de ${min} à ${max}`;
86
+ throw refus(`${nom} doit être un nombre${entier ? ' entier' : ''} ${borne} ; reçu « ${valeur} ».`);
87
+ }
88
+ return valeur;
89
+ }
90
+
91
+ function liste(nom, valeur, { max } = {}) {
92
+ if (!Array.isArray(valeur) || valeur.length === 0) throw refus(`${nom} doit être une liste non vide.`);
93
+ if (max !== undefined && valeur.length > max) throw refus(`${nom} : ${max} au plus (Apple ignore le reste) ; reçu ${valeur.length}.`);
94
+ return valeur;
95
+ }
96
+
97
+ /* Un objet aux clés connues : une clé mal écrite est refusée, au lieu d'être
98
+ ignorée par Apple sans un mot. */
99
+ function objetConnu(nom, valeur, cles) {
100
+ if (!objetSimple(valeur)) throw refus(`${nom} doit être un objet.`);
101
+ const inconnue = Object.keys(valeur).find((cle) => !cles.includes(cle));
102
+ if (inconnue) throw refus(`${nom} : clé inconnue « ${inconnue} » (attendu : ${cles.join(', ')}).`);
103
+ return valeur;
104
+ }
105
+
106
+ function sansVides(objet) {
107
+ return Object.fromEntries(Object.entries(objet).filter(([, valeur]) => valeur !== undefined));
108
+ }
109
+
110
+ function plageDeDates(nom, valeur) {
111
+ objetConnu(nom, valeur, ['date', 'startDate', 'endDate']);
112
+ if (valeur.date !== undefined) {
113
+ if (valeur.startDate !== undefined || valeur.endDate !== undefined) {
114
+ throw refus(`${nom} : soit date, soit startDate et endDate, pas les deux.`);
115
+ }
116
+ return { date: date(`${nom}.date`, valeur.date) };
117
+ }
118
+ if (valeur.startDate === undefined || valeur.endDate === undefined) {
119
+ throw refus(`${nom} : startDate et endDate vont ensemble (ou une seule date dans date).`);
120
+ }
121
+ const debut = date(`${nom}.startDate`, valeur.startDate);
122
+ const fin = date(`${nom}.endDate`, valeur.endDate);
123
+ const [t0, t1] = [Date.parse(debut), Date.parse(fin)];
124
+ if (!Number.isNaN(t0) && !Number.isNaN(t1) && t1 <= t0) throw refus(`${nom} : endDate doit venir après startDate.`);
125
+ return { startDate: debut, endDate: fin };
126
+ }
127
+
128
+ function lieu(nom, valeur) {
129
+ objetConnu(nom, valeur, ['latitude', 'longitude', 'altitude', 'relevantText']);
130
+ return sansVides({
131
+ latitude: nombre(`${nom}.latitude`, valeur.latitude, { min: -90, max: 90 }),
132
+ longitude: nombre(`${nom}.longitude`, valeur.longitude, { min: -180, max: 180 }),
133
+ altitude: valeur.altitude === undefined ? undefined : nombre(`${nom}.altitude`, valeur.altitude),
134
+ relevantText: valeur.relevantText === undefined ? undefined : texte(`${nom}.relevantText`, valeur.relevantText)
135
+ });
136
+ }
137
+
138
+ function balise(nom, valeur) {
139
+ objetConnu(nom, valeur, ['proximityUUID', 'major', 'minor', 'relevantText']);
140
+ if (typeof valeur.proximityUUID !== 'string' || !UUID.test(valeur.proximityUUID)) {
141
+ throw refus(`${nom}.proximityUUID doit être un UUID ; reçu « ${valeur.proximityUUID} ».`);
142
+ }
143
+ const seize = { min: 0, max: 65535, entier: true };
144
+ return sansVides({
145
+ proximityUUID: valeur.proximityUUID,
146
+ major: valeur.major === undefined ? undefined : nombre(`${nom}.major`, valeur.major, seize),
147
+ minor: valeur.minor === undefined ? undefined : nombre(`${nom}.minor`, valeur.minor, seize),
148
+ relevantText: valeur.relevantText === undefined ? undefined : texte(`${nom}.relevantText`, valeur.relevantText)
149
+ });
150
+ }
151
+
152
+ function nfc(nom, valeur) {
153
+ objetConnu(nom, valeur, ['message', 'encryptionPublicKey', 'requiresAuthentication']);
154
+ texte(`${nom}.message`, valeur.message);
155
+ if (Buffer.byteLength(valeur.message, 'utf8') > 64) throw refus(`${nom}.message : 64 octets au plus (Apple coupe le reste).`);
156
+ return sansVides({
157
+ message: valeur.message,
158
+ encryptionPublicKey: texte(`${nom}.encryptionPublicKey`, valeur.encryptionPublicKey),
159
+ requiresAuthentication: valeur.requiresAuthentication === undefined
160
+ ? undefined : booleen(`${nom}.requiresAuthentication`, valeur.requiresAuthentication)
161
+ });
162
+ }
163
+
164
+ const identifiantsApp = (nom, valeur) => liste(nom, valeur)
165
+ .map((id, i) => nombre(`${nom}[${i}]`, id, { min: 0, entier: true, strict: true }));
166
+
167
+ /* Liens du guide de l'événement (billets en affiche) et des cartes
168
+ d'embarquement (iOS 26) ; tous en http(s). */
169
+ const ADRESSES = [
170
+ 'accessibilityURL', 'addOnURL', 'bagPolicyURL', 'contactVenueWebsite', 'directionsInformationURL',
171
+ 'merchandiseURL', 'orderFoodURL', 'parkingInformationURL', 'purchaseParkingURL', 'sellURL',
172
+ 'transferURL', 'transitInformationURL',
173
+ 'changeSeatURL', 'entertainmentURL', 'managementURL', 'purchaseAdditionalBaggageURL',
174
+ 'purchaseLoungeAccessURL', 'purchaseWifiURL', 'registerServiceAnimalURL', 'reportLostBagURL',
175
+ 'requestWheelchairURL', 'trackBagsURL', 'transitProviderWebsiteURL', 'upgradeURL'
176
+ ];
177
+
178
+ /** Chaque clé de premier niveau prise en charge, avec son contrôle. */
179
+ const OPTIONS = {
180
+ relevantDate: date,
181
+ relevantDates: (nom, valeur) => liste(nom, valeur).map((plage, i) => plageDeDates(`${nom}[${i}]`, plage)),
182
+ expirationDate: date,
183
+ locations: (nom, valeur) => liste(nom, valeur, { max: 10 }).map((l, i) => lieu(`${nom}[${i}]`, l)),
184
+ maxDistance: (nom, valeur) => nombre(nom, valeur, { min: 0, strict: true }),
185
+ beacons: (nom, valeur) => liste(nom, valeur, { max: 10 }).map((b, i) => balise(`${nom}[${i}]`, b)),
186
+ groupingIdentifier: texte,
187
+ sharingProhibited: booleen,
188
+ suppressStripShine: booleen,
189
+ semantics: (nom, valeur) => {
190
+ if (!objetSimple(valeur)) throw refus(`${nom} doit être un objet (les étiquettes sémantiques d'Apple).`);
191
+ return jsonSur(nom, valeur);
192
+ },
193
+ userInfo: (nom, valeur) => {
194
+ if (!objetSimple(valeur)) throw refus(`${nom} doit être un objet.`);
195
+ return jsonSur(nom, valeur);
196
+ },
197
+ preferredStyleSchemes: (nom, valeur) => liste(nom, valeur).map((s, i) => texte(`${nom}[${i}]`, s)),
198
+ eventLogoText: texte,
199
+ footerBackgroundColor: couleur,
200
+ useAutomaticColors: booleen,
201
+ suppressHeaderDarkening: booleen,
202
+ contactVenueEmail: texte,
203
+ contactVenuePhoneNumber: texte,
204
+ transitProviderEmail: texte,
205
+ transitProviderPhoneNumber: texte,
206
+ associatedStoreIdentifiers: identifiantsApp,
207
+ auxiliaryStoreIdentifiers: identifiantsApp,
208
+ /* Passée telle quelle à l'application : un schéma propre (monapp://) est permis. */
209
+ appLaunchURL: texte,
210
+ nfc,
211
+ ...Object.fromEntries(ADRESSES.map((nom) => [nom, adresse]))
212
+ };
213
+
214
+ /* Les clés que le paquet écrit lui-même : extraKeys ne peut pas les
215
+ remplacer, pour ne pas contourner leurs contrôles. */
216
+ const GEREES = [
217
+ 'formatVersion', 'passTypeIdentifier', 'teamIdentifier', 'serialNumber', 'organizationName',
218
+ 'description', 'logoText', 'foregroundColor', 'backgroundColor', 'labelColor', 'webServiceURL',
219
+ 'authenticationToken', 'voided', 'barcode', 'barcodes',
220
+ 'storeCard', 'generic', 'coupon', 'eventTicket', 'boardingPass', 'posterGeneric'
221
+ ];
222
+
223
+ /**
224
+ * Contrôle les clés de premier niveau et les rend prêtes à écrire.
225
+ * @param {Record<string, unknown>} options clés de OPTIONS (absentes : ignorées).
226
+ * @param {Record<string, unknown>} [extra] autres clés d'Apple, écrites telles quelles.
227
+ */
228
+ function preparerOptions(options = {}, extra) {
229
+ const resultat = {};
230
+ for (const [nom, controle] of Object.entries(OPTIONS)) {
231
+ if (options[nom] !== undefined && options[nom] !== null) resultat[nom] = controle(nom, options[nom]);
232
+ }
233
+ if (extra !== undefined && extra !== null) {
234
+ if (!objetSimple(extra)) throw refus('extraKeys doit être un objet { cléApple: valeur }.');
235
+ for (const [nom, valeur] of Object.entries(extra)) {
236
+ if (GEREES.includes(nom)) throw refus(`extraKeys ne peut pas remplacer « ${nom} », que le paquet écrit lui-même.`);
237
+ if (Object.hasOwn(OPTIONS, nom)) throw refus(`« ${nom} » se donne directement (avec son contrôle), pas dans extraKeys.`);
238
+ if (valeur !== undefined) resultat[nom] = jsonSur(`extraKeys.${nom}`, valeur);
239
+ }
240
+ }
241
+ return resultat;
242
+ }
243
+
244
+ module.exports = { preparerOptions, date, jsonSur, couleur, OPTIONS, NOMS_OPTIONS: Object.keys(OPTIONS) };
@@ -0,0 +1,281 @@
1
+ const crypto = require('node:crypto');
2
+ const { signerDetache } = require('./signature');
3
+ const { creerZip } = require('./zip');
4
+ const { preparerOptions, date: dateApple, couleur } = require('./options');
5
+
6
+ /* Fabrication d'un .pkpass : pass.json, les images, le manifest.json (SHA-1
7
+ de chaque fichier, format imposé par Apple), sa signature, le tout dans un
8
+ ZIP. Apple Wallet refuse sans explication une carte mal formée : tout ce
9
+ qu'on peut contrôler ici l'est, avec un message qui dit quoi corriger. */
10
+
11
+ const TYPES = ['storeCard', 'generic', 'coupon', 'eventTicket', 'boardingPass'];
12
+ /* Écrites sur toute carte, vides comprises. */
13
+ const ZONES = ['headerFields', 'primaryFields', 'secondaryFields', 'auxiliaryFields', 'backFields'];
14
+ /* Section « Informations » sous la carte (iOS 18) : écrite seulement si remplie. */
15
+ const ZONE_INFOS = 'additionalInfoFields';
16
+ /* Carte en affiche (posterGeneric, iOS 27), écrite à côté du style classique
17
+ que gardent les appareils plus anciens. */
18
+ const ZONES_AFFICHE = ['headerFields', 'primaryFields', 'footerFields', 'backFields', 'additionalInfoFields'];
19
+ const TYPES_AVEC_AFFICHE = ['storeCard', 'generic', 'coupon', 'eventTicket'];
20
+ const TRANSPORTS = ['PKTransitTypeAir', 'PKTransitTypeBoat', 'PKTransitTypeBus', 'PKTransitTypeGeneric', 'PKTransitTypeTrain'];
21
+ /* Les quatre formats lus par tous les appareils, puis ceux d'iOS 27. */
22
+ const FORMATS_CLASSIQUES = ['PKBarcodeFormatQR', 'PKBarcodeFormatPDF417', 'PKBarcodeFormatAztec', 'PKBarcodeFormatCode128'];
23
+ const FORMATS_CODE = [...FORMATS_CLASSIQUES, 'PKBarcodeFormatCode39', 'PKBarcodeFormatCodabar', 'PKBarcodeFormatEAN13', 'PKBarcodeFormatI2of5'];
24
+ const COULEURS = ['foregroundColor', 'backgroundColor', 'labelColor'];
25
+ const RESERVES = ['pass.json', 'manifest.json', 'signature'];
26
+ const ICONE = /(?:^|\/)icon(?:@[23]x)?\.png$/;
27
+
28
+ function refus(message) {
29
+ return new TypeError(`Carte Apple Wallet : ${message}`);
30
+ }
31
+
32
+ const texteNonVide = (valeur) => typeof valeur === 'string' && valeur.trim().length > 0;
33
+
34
+ /**
35
+ * Lit et contrôle ce qui signe les cartes, une fois pour toutes : une clé qui
36
+ * ne va pas avec le certificat, ou une phrase secrète fausse, se voit tout de
37
+ * suite et non à la première carte demandée par un client.
38
+ */
39
+ function preparerSignataire({ certificate, privateKey, passphrase, wwdr }) {
40
+ let certificat;
41
+ try {
42
+ certificat = new crypto.X509Certificate(certificate);
43
+ } catch {
44
+ throw new Error('Certificat Pass Type ID illisible ou incomplet.');
45
+ }
46
+ let cle;
47
+ try {
48
+ /* Une phrase absente arrive souvent à null depuis une base : Node la
49
+ refuserait sous cette forme. */
50
+ cle = crypto.createPrivateKey(passphrase == null ? privateKey : { key: privateKey, passphrase });
51
+ } catch {
52
+ throw new Error('Clé privée Apple Wallet illisible, ou phrase secrète fausse.');
53
+ }
54
+ if (!certificat.checkPrivateKey(cle)) throw new Error('La clé privée ne correspond pas au certificat Apple Wallet.');
55
+ let intermediaire;
56
+ try {
57
+ intermediaire = new crypto.X509Certificate(wwdr);
58
+ } catch {
59
+ throw new Error('Certificat intermédiaire Apple (WWDR) illisible.');
60
+ }
61
+ return { certificat, cle, chaine: [intermediaire] };
62
+ }
63
+
64
+ function verifierCouleurs(couleurs) {
65
+ for (const [nom, valeur] of Object.entries(couleurs)) {
66
+ if (!COULEURS.includes(nom)) throw refus(`couleur inconnue « ${nom} » (attendu : ${COULEURS.join(', ')}).`);
67
+ couleur(nom, valeur);
68
+ }
69
+ }
70
+
71
+ const valeurDeChamp = (valeur) => typeof valeur === 'string' || valeur instanceof Date
72
+ || (typeof valeur === 'number' && Number.isFinite(valeur));
73
+
74
+ /* Contrôle les zones d'un style (eventTicket, posterGeneric…). Une clé est
75
+ unique dans tout le style, recto, dos et informations confondus ; le style
76
+ en affiche reprend souvent les clés du style classique, comme dans
77
+ l'exemple d'Apple. */
78
+ function verifierChamps(contenu, zones, style) {
79
+ const cles = new Set();
80
+ for (const zone of zones) {
81
+ const champs = contenu[zone];
82
+ if (champs === undefined || champs === null) continue;
83
+ if (!Array.isArray(champs)) throw refus(`${zone} doit être une liste de champs.`);
84
+ for (const champ of champs) {
85
+ if (!champ || typeof champ !== 'object' || Array.isArray(champ)) throw refus(`un champ de ${zone} n'est pas un objet.`);
86
+ if (!texteNonVide(champ.key)) throw refus(`un champ de ${zone} n'a pas de clé (key).`);
87
+ if (!valeurDeChamp(champ.value)) throw refus(`le champ « ${champ.key} » doit avoir une valeur (value) texte, nombre ou Date.`);
88
+ if (champ.value instanceof Date) dateApple(`la valeur du champ « ${champ.key} »`, champ.value);
89
+ if (champ.attributedValue !== undefined && !valeurDeChamp(champ.attributedValue)) {
90
+ throw refus(`attributedValue du champ « ${champ.key} » doit être un texte, un nombre ou une Date.`);
91
+ }
92
+ if (champ.attributedValue instanceof Date) dateApple(`attributedValue du champ « ${champ.key} »`, champ.attributedValue);
93
+ if (champ.label !== undefined && typeof champ.label !== 'string') throw refus(`le libellé du champ « ${champ.key} » doit être un texte.`);
94
+ if (cles.has(champ.key)) {
95
+ throw refus(`deux champs ont la clé « ${champ.key} » ; chaque clé doit être unique dans ${style}.`);
96
+ }
97
+ cles.add(champ.key);
98
+ }
99
+ }
100
+ }
101
+
102
+ function verifierCode(code) {
103
+ if (!code || typeof code !== 'object') throw refus('le code-barres doit être un objet { message, format?, altText? }.');
104
+ if (!texteNonVide(code.message)) throw refus('le code-barres n\'a pas de message.');
105
+ if (!FORMATS_CODE.includes(code.format)) throw refus(`format de code-barres inconnu « ${code.format} » (attendu : ${FORMATS_CODE.join(', ')}).`);
106
+ if (code.altText !== undefined && typeof code.altText !== 'string') throw refus('le texte du code-barres (altText) doit être un texte.');
107
+ if (code.messageEncoding !== undefined && !texteNonVide(code.messageEncoding)) {
108
+ throw refus('messageEncoding du code-barres doit être un nom de jeu de caractères (iso-8859-1, utf-8…).');
109
+ }
110
+ }
111
+
112
+ /* Les codes de la carte : un seul (barcode) ou une liste (barcodes), le
113
+ premier lisible par l'appareil étant affiché. Les formats d'iOS 27 ne
114
+ s'affichent pas plus tôt : un format classique doit suivre, sinon le
115
+ billet n'aurait aucun code sur les autres téléphones. */
116
+ function codesDe(pass) {
117
+ if (pass.barcode !== undefined && pass.barcodes !== undefined) throw refus('barcode ou barcodes, pas les deux.');
118
+ if (pass.barcodes === undefined) return pass.barcode === undefined ? [] : [pass.barcode];
119
+ if (!Array.isArray(pass.barcodes) || pass.barcodes.length === 0) throw refus('barcodes doit être une liste non vide de codes.');
120
+ return pass.barcodes;
121
+ }
122
+
123
+ function verifierCodes(codes) {
124
+ codes.forEach(verifierCode);
125
+ if (codes.length > 0 && !codes.some((code) => FORMATS_CLASSIQUES.includes(code.format))) {
126
+ throw refus(`les formats ${codes.map((code) => code.format).join(', ')} ne s'affichent qu'à partir d'iOS 27 ; ajoutez après un code ${FORMATS_CLASSIQUES.join(', ')} pour les autres appareils.`);
127
+ }
128
+ }
129
+
130
+ /** Contrôle la description complète d'une carte (le futur pass.json). */
131
+ function verifierPass(pass) {
132
+ if (!TYPES.includes(pass.type)) throw refus(`type inconnu « ${pass.type} » (attendu : ${TYPES.join(', ')}).`);
133
+ for (const nom of ['serialNumber', 'organizationName', 'description']) {
134
+ if (!texteNonVide(pass[nom])) throw refus(`${nom} est obligatoire.`);
135
+ }
136
+ if (pass.logoText !== undefined && typeof pass.logoText !== 'string') throw refus('logoText doit être un texte.');
137
+ if (pass.webServiceURL !== undefined) {
138
+ let adresse;
139
+ try {
140
+ adresse = new URL(pass.webServiceURL);
141
+ } catch {
142
+ throw refus(`webServiceURL n'est pas une adresse : « ${pass.webServiceURL} ».`);
143
+ }
144
+ if (!['https:', 'http:'].includes(adresse.protocol)) throw refus('webServiceURL doit commencer par https://.');
145
+ if (typeof pass.authenticationToken !== 'string' || pass.authenticationToken.length < 16) {
146
+ throw refus('avec un service web, authenticationToken doit faire au moins 16 caractères (exigence Apple).');
147
+ }
148
+ }
149
+ verifierCouleurs(pass.colors || {});
150
+ if (pass.type === 'boardingPass') {
151
+ if (!TRANSPORTS.includes(pass.transitType)) {
152
+ throw refus(`une carte d'embarquement demande transitType (attendu : ${TRANSPORTS.join(', ')}) ; reçu « ${pass.transitType} ».`);
153
+ }
154
+ } else if (pass.transitType !== undefined) {
155
+ throw refus('transitType ne sert qu\'aux cartes d\'embarquement (type boardingPass).');
156
+ }
157
+ verifierChamps(pass.fields || {}, [...ZONES, ZONE_INFOS], pass.type);
158
+ if (pass.posterGeneric !== undefined && pass.posterGeneric !== null) {
159
+ if (!TYPES_AVEC_AFFICHE.includes(pass.type)) {
160
+ throw refus(`posterGeneric s'ajoute à une carte ${TYPES_AVEC_AFFICHE.join(', ')}, pas à ${pass.type}.`);
161
+ }
162
+ if (typeof pass.posterGeneric !== 'object' || Array.isArray(pass.posterGeneric)) {
163
+ throw refus('posterGeneric doit être un objet de zones (headerFields, primaryFields…).');
164
+ }
165
+ const inconnue = Object.keys(pass.posterGeneric).find((zone) => !ZONES_AFFICHE.includes(zone));
166
+ if (inconnue) throw refus(`posterGeneric : zone inconnue « ${inconnue} » (attendu : ${ZONES_AFFICHE.join(', ')}).`);
167
+ verifierChamps(pass.posterGeneric, ZONES_AFFICHE, 'posterGeneric');
168
+ /* Apple affiche l'affiche en priorité dès qu'elle est là : vide, elle
169
+ cacherait la carte classique sur iOS 27. */
170
+ if (!ZONES_AFFICHE.some((zone) => pass.posterGeneric[zone]?.length > 0)) {
171
+ throw refus('posterGeneric n\'a aucun champ ; il cacherait la carte classique sur iOS 27.');
172
+ }
173
+ }
174
+ verifierCodes(codesDe(pass));
175
+ }
176
+
177
+ /** Contrôle les fichiers joints (images) et les rend en Buffer. */
178
+ function verifierFichiers(fichiers) {
179
+ const resultat = [];
180
+ for (const [nom, contenu] of Object.entries(fichiers)) {
181
+ const morceaux = nom.split('/');
182
+ const sur = nom.length > 0 && !nom.includes('\\') && !nom.startsWith('/')
183
+ && morceaux.every((morceau) => morceau !== '' && morceau !== '.' && morceau !== '..');
184
+ if (!sur) throw refus(`nom de fichier refusé « ${nom} » : un chemin relatif, sans « .. » ni barre oblique inverse.`);
185
+ if (RESERVES.includes(nom.toLowerCase())) throw refus(`« ${nom} » est fabriqué par le paquet ; il ne se fournit pas.`);
186
+ if (!(contenu instanceof Uint8Array)) throw refus(`le fichier « ${nom} » doit être un Buffer.`);
187
+ resultat.push({ name: nom, data: Buffer.from(contenu.buffer, contenu.byteOffset, contenu.byteLength) });
188
+ }
189
+ if (!resultat.some(({ name }) => ICONE.test(name))) {
190
+ throw refus('icon.png manque ; aucun appareil Apple n\'ouvre une carte sans icône.');
191
+ }
192
+ return resultat;
193
+ }
194
+
195
+ /* Un champ tel qu'Apple le lit : une Date devient un texte ISO 8601. */
196
+ function champJson(champ) {
197
+ const copie = { ...champ };
198
+ for (const nom of ['value', 'attributedValue']) {
199
+ if (copie[nom] instanceof Date) copie[nom] = copie[nom].toISOString();
200
+ }
201
+ return copie;
202
+ }
203
+
204
+ const champsDe = (contenu, zone) => (contenu?.[zone] || []).map(champJson);
205
+
206
+ /**
207
+ * Le pass.json, dans l'ordre où Apple le documente.
208
+ * @param {object} pass
209
+ * @param {Record<string, unknown>} [supplement] clés de premier niveau déjà contrôlées (preparerOptions).
210
+ */
211
+ function passJson(pass, supplement = {}) {
212
+ const corps = {};
213
+ if (pass.type === 'boardingPass') corps.transitType = pass.transitType;
214
+ /* Les cinq zones toujours présentes, vides comprises : c'est la forme que
215
+ produisait passkit-generator, éprouvée sur les appareils. */
216
+ for (const zone of ZONES) corps[zone] = champsDe(pass.fields, zone);
217
+ const infos = champsDe(pass.fields, ZONE_INFOS);
218
+ if (infos.length > 0) corps[ZONE_INFOS] = infos;
219
+ let affiche;
220
+ if (pass.posterGeneric) {
221
+ affiche = {};
222
+ for (const zone of ZONES_AFFICHE) {
223
+ const champs = champsDe(pass.posterGeneric, zone);
224
+ if (champs.length > 0) affiche[zone] = champs;
225
+ }
226
+ }
227
+ const codes = codesDe(pass);
228
+ return {
229
+ formatVersion: 1,
230
+ passTypeIdentifier: pass.passTypeIdentifier,
231
+ teamIdentifier: pass.teamIdentifier,
232
+ serialNumber: pass.serialNumber,
233
+ organizationName: pass.organizationName,
234
+ description: pass.description,
235
+ ...(pass.logoText !== undefined ? { logoText: pass.logoText } : {}),
236
+ ...(pass.colors || {}),
237
+ ...(pass.webServiceURL !== undefined
238
+ ? { webServiceURL: pass.webServiceURL, authenticationToken: pass.authenticationToken }
239
+ : {}),
240
+ ...(pass.voided ? { voided: true } : {}),
241
+ ...supplement,
242
+ ...(codes.length > 0
243
+ ? {
244
+ barcodes: codes.map((code) => ({
245
+ format: code.format,
246
+ message: code.message,
247
+ messageEncoding: code.messageEncoding || 'utf-8',
248
+ ...(code.altText !== undefined ? { altText: code.altText } : {})
249
+ }))
250
+ }
251
+ : {}),
252
+ [pass.type]: corps,
253
+ ...(affiche ? { posterGeneric: affiche } : {})
254
+ };
255
+ }
256
+
257
+ /**
258
+ * @param {object} entree
259
+ * @param {object} entree.pass description de la carte (voir verifierPass).
260
+ * @param {Record<string, Uint8Array>} entree.fichiers images.
261
+ * @param {ReturnType<typeof preparerSignataire>} entree.signataire
262
+ * @param {Date} [entree.date] heure de signature et date des fichiers.
263
+ * @returns {Buffer} le .pkpass
264
+ */
265
+ function fabriquerPkpass({ pass, fichiers, signataire, date = new Date() }) {
266
+ verifierPass(pass);
267
+ const supplement = preparerOptions(pass.options, pass.extraKeys);
268
+ const images = verifierFichiers(fichiers);
269
+ const contenu = [{ name: 'pass.json', data: Buffer.from(JSON.stringify(passJson(pass, supplement)), 'utf8') }, ...images];
270
+ const manifeste = {};
271
+ for (const { name, data } of contenu) manifeste[name] = crypto.createHash('sha1').update(data).digest('hex');
272
+ const manifesteJson = Buffer.from(JSON.stringify(manifeste), 'utf8');
273
+ const signature = signerDetache(manifesteJson, { ...signataire, date });
274
+ return creerZip([
275
+ ...contenu,
276
+ { name: 'manifest.json', data: manifesteJson },
277
+ { name: 'signature', data: signature }
278
+ ], date);
279
+ }
280
+
281
+ module.exports = { fabriquerPkpass, preparerSignataire, passJson, TYPES, FORMATS_CODE };