Data Ghost : cryptologie kabbalistique
p. 193-208
Texte intégral
1Le collectif RYBN travaille aussi bien sur les algorithmes du speed-trading de la finance que sur la façon dont nos subjectivités se trouvent reconditionnées à la fois par la présence (souvent cachée) et par les autoproclamations (souvent exagérées) d’un numérique désormais réputé être ubiquitaire. Ses activités sont documentées sur son site Internet : http://rybn.org/.
2Pour la pièce Data Ghost 2 présentée à Cerisy, ils ont créé un daemon qui intercepte des contenus circulant sur Internet pour mettre en scène leur reformulation selon diverses procédures inspirées de la Kabbale, cette ancienne tradition juive reposant sur de mystérieuses correspondances entre lettres et chiffres, entre formules occultes et opérations surnaturelles. En tant que procédure d’interprétation, la Kabbale était elle-même une certaine forme d’attention aux textes sacrés, une attention d’autant plus puissante, dans sa transformation de la matière par la vertu du symbolique, qu’elle resterait plus fidèle à la lettre des textes, ainsi qu’à leur chiffre supposé.
3Qu’il gouverne nos modes de régulation biopolitique ou nos cotations boursières, le code informatique joue aujourd’hui ce rôle de transformateur de réalité matérielle pa2r la pure puissance de manipulations symboliques. En faisant mine de court-circuiter toute attention subjective humaine, pour laisser les données et les algorithmes organiser notre monde par leur logique propre, l’attention machinique de nos appareillages numériques semble réaliser aujourd’hui un idéal archaïque que seuls les plus audacieux penseurs de la Kabbale ont pu parvenir à imaginer.
4Afin de nous donner une certaine expérience intuitive de la façon dont opère cette attention machinique, RYBN a proposé, en guise de contribution à ce volume, la version imprimée du code-source de Data Ghost 2. À nous de voir ce que nous sommes capables (ou non) d’y « lire », d’y « comprendre », d’y « interpréter » – autant de termes dont l’application au cas présent est pour le moins problématique. C’est à cette problématisation – qui ne saurait être réservée aux seuls virtuoses de la programmation numérique, puisqu’elle nous concerne toutes et tous – que ce dispositif espère contribuer.
5Quel type d’attention pouvons-nous prêter aux lignes de codes qui programment des parts toujours plus larges de nos vies ? À quoi ressemblent-elles ? Au-delà ou en deçà de ce qu’elles nous font, que peuvent-elles nous dire ?
6(Y. C.)
7Data Ghost 2 explore l'usage des systèmes herméneutiques d'interprétation de la Kabbale, appliqués aux communications réseau, afin de mettre au jour les messages cachés qui y sont enfouis. Un daemon, installé sur un serveur, capte toutes les communications numériques qui en entrent ou en sortent, et redirige leur contenu en utilisant des outils d’interception du réseau. Toutes les données ainsi obtenues sont alors soumises à différents algorithmes de déchiffrage, qui reproduisent les techniques herméneutiques de la Kabbale : Gematria, Temurah et Notarikon. Les données brutes sont décomposées et recomposées selon les principes de substitution qui gouvernent la Kabbale, de façon à dévoiler la mystique des communications en réseaux.
# coding: utf-8
"""
Data Ghost 2 :
Kabbalistic Cryptology
"And with them, He depicted all that was formed
and all that would be formed."
Sefer Yezira
_
Convert a text using differents Kabbalistic Hermeneutics.
Hermeneutic technics:
- gematria: kabbale.gematria()
- notarikon: kabbale.notarikon0() or kabbale.notarikon1()
- temura: kabbale.temura0(), kabbale.temura1(), kabbale.temura2() or kabbale.temura3()
"""
import json
import re
import random
import ntpath
### dict of the different gematrias
# Henri-Corneille Agrippa de Nettesheim Gematria in "De Occulta Philosopha" Book II, Chap 20., 1533
d_gematria_decimale = {'A':1,'B':2,'C':3,'D':4,'E':5,'F':6,'G':7,'H':8,'I':9,'J':600,'K':10,'L':20,'M':30,
'N':40,'O':50,'P':60,'Q':70,'R':80,'S':90,'T':100,'U':200,'V':700,'W':900,'X':300,'Y':400,'Z':500,
'a':1,'b':2,'c':3,'d':4,'e':5,'f':6,'g':7,'h':8,'i':9,'j':600,'k':10,'l':20,'m':30,
'n':40,'o':50,'p':60,'q':70,'r':80,'s':90,'t':100,'u':200,'v':700,'w':900,'x':300,'y':400,'z':500,' ':0}
# Gematria, simple
d_gematria_simple = {'A':1,'B':2,'C':3,'D':4,'E':5,'F':6,'G':7,'H':8,'I':9,'J':9,'K':10,'L':11,'M':12,
'N':13,'O':14,'P':15,'Q':16,'R':17,'S':18,'T':19,'U':20,'V':20,'W':21,'X':22,'Y':23,'Z':24,
'a':1,'b':2,'c':3,'d':4,'e':5,'f':6,'g':7,'h':8,'i':9,'j':9,'k':10,'l':11,'m':12,
'n':13,'o':14,'p':15,'q':16,'r':17,'s':18,'t':19,'u':20,'v':20,'w':21,'x':22,'y':23,'z':24,' ':0}
# Gematria, english
d_gematria_english = {'A':6,'B':12,'C':18,'D':24,'E':30,'F':36,'G':42,'H':48,'I':54,'J':60,'K':66,'L':72,'M':78,
'N':84,'O':90,'P':96,'Q':102,'R':108,'S':114,'T':120,'U':126,'V':132,'W':138,'X':144,'Y':150,'Z':156,
'a':6,'b':12,'c':18,'d':24,'e':30,'f':36,'g':42,'h':48,'i':54,'j':60,'k':66,'l':72,'m':78,
'n':84,'o':90,'p':96,'q':102,'r':108,'s':114,'t':120,'u':126,'v':132,'w':138,'x':144,'y':150,'z':156,' ':0}
# dict correspondance key=symbol_gematria value=corresponding dict gematria
d_type_kabbale = {'G0':d_gematria_decimale, 'G1':d_gematria_simple, 'G2':d_gematria_english}
### dict of the different Temura
# Temura 0
d_temura0 = {'A':'Z','B':'Y','C':'X','D':'W','E':'V','F':'U','G':'T','H':'S','I':'R','J':'Q','K':'P','L':'O','M':'N',
'N':'M','O':'L','P':'K','Q':'J','R':'I','S':'H','T':'G','U':'F','V':'E','W':'D','X':'C','Y':'B','Z':'A',
'a':'z','b':'y','c':'x','d':'w','e':'v','f':'u','g':'t','h':'s','i':'r','j':'q','k':'p','l':'o','m':'n',
'n':'m','o':'l','p':'k','q':'j','r':'i','s':'h','t':'g','u':'f','v':'e','w':'d','x':'c','y':'b','z':'a',
' ':' '}
# Temura 1
d_temura1 = {'A':'B','B':'A','C':'D','D':'C','E':'F','F':'E','G':'H','H':'G','I':'J','J':'I','K':'L','L':'K','M':'N',
'N':'M','O':'P','P':'O','Q':'R','R':'Q','S':'T','T':'S','U':'V','V':'U','W':'X','X':'W','Y':'Z','Z':'Y',
'a':'b','b':'a','c':'d','d':'c','e':'f','f':'e','g':'h','h':'g','i':'j','j':'i','k':'l','l':'k','m':'n',
'n':'m','o':'p','p':'o','q':'r','r':'q','s':'t','t':'s','u':'v','v':'u','w':'x','x':'w','y':'z','z':'y',
' ':' '}
def _get_only_letters_and_spaces(line):
pattern = re.compile(r'[^a-zA-Z ]+')
line = pattern.sub(' ', line)
line_only_char = ' '.join(line.split())
return line_only_char
def _get_only_one_result(l_res):
l_res_filtre = []
for ligne_brut, list_res in l_res:
if list_res:
random_elem = random.sample(list_res, 1)
l_res_filtre.append((ligne_brut, random_elem))
else:
l_res_filtre.append((ligne_brut, ''))
return l_res_filtre
def _json_to_dict_gematria(type_gematria, chemin_origine_equivalence):
basename = ntpath.basename(chemin_origine_equivalence)
filename = type_gematria+"_"+basename
file = 'json_correspondance/{}.json'.format(filename)
try:
with open(file, 'r') as f:
json_correspondance = f.read()
d_json_correspondance = json.loads(json_correspondance)
except:
from create_json_correspondance import from_line_by_line
print('JSON correspondance not found. creating it in directory "json_correspondance"')
from_line_by_line(type_gematria, chemin_origine_equivalence)
with open(file, 'r') as f:
json_correspondance = f.read()
d_json_correspondance = json.loads(json_correspondance)
return d_json_correspondance
def gematria(type_gematria, text_path, chemin_origine_equivalence):
"""
GEMATRIA
"And before One, what do you count?"
"Two stones build 2 houses
Three stones build 6 houses
Four stones build 24 houses
Five stones build 120 houses
Six stones build 620 houses
Seven stones build 5040 houses
From here on go out and calculate
that which the mouth cannot speak
and the ear cannot hear."
Sefer Yezira
_
Convert a text with the Gematria hermeneutic technic.
:param type_gematria: The symbol of gematria to use
'G0' for the Mystic Gematria
'G1' for the Sidori Gematria
'G2' for the ??? Gematria
:param text_path: The path of the text to convert
:param chemin_origine_equivalence: The path of the 'sacred' text
:type type_gematria: str
:type text_path: str
:type chemin_origine_equivalence: str
:return: List of tupples (string, list) where 'string' is the original line and 'list' is a list containing all possible results.
The 'list' is empty if there is no result
:rtype: list
"""
# get dict from origanal text where key=sum and value=base_text
d_json_correspondance = _json_to_dict_gematria(type_gematria, chemin_origine_equivalence)
l_decodage = []
# get dict of corresponding gematria
d_kabbale = d_type_kabbale[type_gematria]
with open(text_path, 'r') as f:
for line in f:
# remove space at beginning and carriage return
line = ' '.join(line.split())
# remove all char that are not letters or a space and put text in uppercase
line_only_char = _get_only_letters_and_spaces(line)
if not line_only_char:
continue
l_split = list(line_only_char)
l_nb = [d_gematria_decimale[char] for char in l_split]
sum_nb = sum(l_nb)
try:
res_corresp = (line, d_json_correspondance[str(sum_nb)])
except KeyError:
# continue
res_corresp = (line, [])
l_decodage.append(res_corresp)
return l_decodage
def notarikon0(text_path):
"""
NOTARIKON
"Twenty-two Foundation letters:
He engraved them, He carved them,
He permuted them, He weighed them,
He transformed them,"
Sefer Yezira,
_
Convert a text with the Notarikon hermeneutic technic:
in each line, replace each letter of a word by a dictionnary word (english dictionnary)
:param text_path: The path of the text to convert
:type text_path: str
:return: List of tupples (string, list) where 'string' is the original line and 'list' is a list containing all possible results.
The 'list' is empty if there is no result
:rtype: list
"""
l_decodage = []
l_mots_dico_english = []
with open('sources_textes/english_dico', 'r') as f:
for line in f:
line = line.rstrip('\n')
l_mots_dico_english.append(line)
s_mots_dico_english = set(l_mots_dico_english)
with open(text_path, 'r') as f:
for line in f:
l_mots = []
line = ' '.join(line.split())
line_only_char = _get_only_letters_and_spaces(line)
if not line_only_char:
continue
l_split = list(line_only_char)
for letter in l_split:
if letter != ' ':
s_mot_dico_sel = {elem for elem in s_mots_dico_english if elem[0] == letter or elem[0] == letter.lower()}
random_elem = random.sample(s_mot_dico_sel, 1)
l_mots.append(random_elem[0])
res_corresp = (line, l_mots)
l_decodage.append(res_corresp)
return l_decodage
def notarikon1(text_path, position_lettre):
"""
NOTARIKON
"Their end is imbedded in their beginning
and their beginning in their end"
Sefer Yezira,
_
Convert a text with the Notarikon hermeneutic technic:
in each line, take only the nth letter of a word
:param text_path: The path of the text to convert
:param position_lettre: The position of the letter to select
:type text_path: str
:type position_lettre: str
:return: List of tupples (string, list) where 'string' is the original line and 'list' is a list containing all possible results.
The 'list' is empty if there is no result
:rtype: list
"""
position_lettre = int(position_lettre)
l_decodage = []
l_mots_dico_english = []
with open('sources_textes/english_dico', 'r') as f:
for line in f:
line = line.rstrip('\n')
l_mots_dico_english.append(line)
s_mots_dico_english = set(l_mots_dico_english)
with open(text_path, 'r') as f:
for line in f:
l_mots = []
line = ' '.join(line.split())
line_only_char = _get_only_letters_and_spaces(line)
if not line_only_char:
continue
l_mots = line_only_char.split(' ')
l_lettre = []
for mot in l_mots:
try:
l_lettre.append(mot[position_lettre])
except:
continue
list_dun_seul_mot = [''.join(l_lettre)]
res_corresp = (line, list_dun_seul_mot)
l_decodage.append(res_corresp)
return l_decodage
def temura0(text_path):
"""
TEMURA
"Twenty-two Foundation Letters:
He placed them in a circle
like a wall with 231 Gates.
The circle oscillates back and forth."
Sefer Yezira,
_
Convert a text with the Temura hermeneutic technic:
in each line, change each letters according to dict 'd_temura0'
:param text_path: The path of the text to convert
:type text_path: str
:return: List of tupples (string, list) where 'string' is the original line and 'list' is a list containing all possible results.
The 'list' is empty if there is no result
:rtype: list
"""
l_decodage = []
with open(text_path, 'r') as f:
for line in f:
line = ' '.join(line.split())
line_only_char = _get_only_letters_and_spaces(line)
if not line_only_char:
continue
l_char_res = [d_temura0[char] for char in line_only_char]
line_res = [''.join(l_char_res)]
res_corresp = (line, line_res)
l_decodage.append(res_corresp)
return l_decodage
def temura1(text_path):
"""
TEMURA
"Understand with Wisdom
Be wise with Understanding
Examine with them
and probe from them"
Sefer Yezira,
_
Convert a text with the Temura hermeneutic technic:
in each line, change each letters according to dict 'd_temura1'
:param text_path: The path of the text to convert
:type text_path: str
:return: List of tupples (string, list) where 'string' is the original line and 'list' is a list containing all possible results.
The 'list' is empty if there is no result
:rtype: list
"""
l_decodage = []
with open(text_path, 'r') as f:
for line in f:
line = ' '.join(line.split())
line_only_char = _get_only_letters_and_spaces(line)
if not line_only_char:
continue
l_char_res = [d_temura1[char] for char in line]
line_res = [''.join(l_char_res)]
res_corresp = (line, line_res)
l_decodage.append(res_corresp)
return l_decodage
def temura2(text_path, decalage):
"""
TEMURA
"He made them like a trough
He arranged them like a wall
He set them up like a battle."
Sefer Yezira,
_
Convert a text with the Temura hermeneutic technic:
in each line, shift each letter
:param text_path: The path of the text to convert
:param decalage: The shift to apply to each letter
:type text_path: str
:type decalage: str
:return: List of tupples (string, list) where 'string' is the original line and 'list' is a list containing all possible results.
The 'list' is empty if there is no result
:rtype: list
"""
decalage = int(decalage)
l_decodage = []
with open(text_path, 'r') as f:
for line in f:
line_res = ''
line = ' '.join(line.split())
line_only_char = _get_only_letters_and_spaces(line)
print(line_only_char)
if not line_only_char:
continue
for char in line_only_char:
ascii = ord(char)
if ascii != 32:
# si lettres en captitale
if ascii < 95:
ascii -= 65
ascii += int(decalage)
ascii = ascii % 26
ascii += 65
# si lettres bas de casse
else:
ascii -= 97
ascii += int(decalage)
ascii = ascii % 26
ascii += 97
char = chr(ascii)
line_res += char
line_res = [line_res]
res_corresp = (line, line_res)
l_decodage.append(res_corresp)
return l_decodage
def temura3(text_path):
"""
TEMURA
"Twenty-two Foundation Letters:
He placed them in a circle
like a wall with 231 Gates.
The circle oscillates back and forth."
Sefer Yezira,
_
Convert a text with the Temura hermeneutic technic:
in each line, reverse letters
:param text_path: The path of the text to convert
:type text_path: str
:return: List of tupples (string, list) where 'string' is the original line and 'list' is a list containing all possible results.
The 'list' is empty if there is no result
:rtype: list
"""
l_decodage = []
with open(text_path, 'r') as f:
for line in f:
line = ' '.join(line.split())
line_only_char = _get_only_letters_and_spaces(line)
if not line_only_char:
continue
line_only_char = line_only_char[::-1]
line_res = [''.join(line_only_char)]
res_corresp = (line, line_res)
l_decodage.append(res_corresp)
return l_decodage
if __name__ == '__main__':
# kabbale, text_path, correspondance_text_path = ('G0', 'python_182.48.18.54_2016-06-07-17:03:23.342932', 'sources_textes/EN_Sepher_Ha-Bahir')
# args_gematria = (kabbale, text_path, correspondance_text_path)
# kabbale, text_path = ('N0', 'python_182.48.18.54_2016-06-07-17:03:23.342932')
# kabbale, text_path, position_lettre = ('N1', 'python_182.48.18.54_2016-06-07-17:03:23.342932', '1')
# kabbale, text_path = ('T0', 'python_182.48.18.54_2016-06-07-17:03:23.342932')
# kabbale, text_path = ('T1', 'python_182.48.18.54_2016-06-07-17:03:23.342932')
# kabbale, text_path, decalage = ('T2', 'python_182.48.18.54_2016-06-07-17:03:23.342932', '1')
kabbale, text_path = ('T3', 'python_182.48.18.54_2016-06-07-17:03:23.342932')
if kabbale == 'G0' or kabbale == 'G1' or kabbale == 'G2':
l_res = gematria(kabbale, text_path, correspondance_text_path)
elif kabbale == 'N0':
l_res = notarikon0(text_path)
elif kabbale == 'N1':
l_res = notarikon1(text_path, position_lettre)
elif kabbale == 'T0':
l_res = temura0(text_path)
elif kabbale == 'T1':
l_res = temura1(text_path)
elif kabbale == 'T2':
l_res = temura2(text_path, decalage)
elif kabbale == 'T3':
l_res = temura3(text_path)
print(l_res)
Auteur
Le texte seul est utilisable sous licence Licence OpenEdition Books. Les autres éléments (illustrations, fichiers annexes importés) sont « Tous droits réservés », sauf mention contraire.
Lire et penser en milieux numériques
Attention, récits, technogenèse
N. Katherine Hayles Christophe Degoutin (trad.)
2016
Des « passeurs » entre science, histoire et littérature
Contribution à l'étude de la construction des savoirs (1750-1840)
Gilles Bertrand et Alain Guyot (dir.)
2011
Technologies de l'enchantement
Pour une histoire multidisciplinaire de l'illusion
Yves Citton et Angela Braito (dir.)
2014