Skip to content
GitLab
Menu
Projects
Groups
Snippets
Help
Help
Support
Community forum
Keyboard shortcuts
?
Submit feedback
Contribute to GitLab
Sign in / Register
Toggle navigation
Menu
Open sidebar
Malte L
gajim-plugins
Commits
8b63fd9b
Commit
8b63fd9b
authored
Feb 12, 2019
by
Philipp Hörist
Browse files
[omemo] Refactor AxolotlStore
- Merge all stores into AxolotlStore
parent
065b3f04
Changes
11
Expand all
Hide whitespace changes
Inline
Side-by-side
omemo/backend/db_helpers.py
deleted
100644 → 0
View file @
065b3f04
''' Database helper functions '''
def
table_exists
(
db
,
name
):
""" Check if the specified table exists in the db. """
query
=
""" SELECT name FROM sqlite_master
WHERE type='table' AND name=?;
"""
return
db
.
execute
(
query
,
(
name
,
)).
fetchone
()
is
not
None
def
user_version
(
db
):
""" Return the value of PRAGMA user_version. """
return
db
.
execute
(
'PRAGMA user_version'
).
fetchone
()[
0
]
omemo/backend/encryption.py
deleted
100644 → 0
View file @
065b3f04
# -*- coding: utf-8 -*-
#
# Copyright 2015 Bahtiar `kalkin-` Gadimov <bahtiar@gadimov.de>
# Copyright 2015 Daniel Gultsch <daniel@cgultsch.de>
#
# This file is part of Gajim-OMEMO plugin.
#
# The Gajim-OMEMO plugin is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by the Free
# Software Foundation, either version 3 of the License, or (at your option) any
# later version.
#
# Gajim-OMEMO is distributed in the hope that it will be useful, but WITHOUT ANY
# WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
# A PARTICULAR PURPOSE. See the GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License along with
# the Gajim-OMEMO plugin. If not, see <http://www.gnu.org/licenses/>.
#
class
EncryptionState
():
""" Used to store if OMEMO is enabled or not between gajim restarts """
def
__init__
(
self
,
dbConn
):
"""
:type dbConn: Connection
"""
self
.
dbConn
=
dbConn
def
activate
(
self
,
jid
):
q
=
"""INSERT OR REPLACE INTO encryption_state (jid, encryption)
VALUES (?, 1) """
c
=
self
.
dbConn
.
cursor
()
c
.
execute
(
q
,
(
jid
,
))
self
.
dbConn
.
commit
()
def
deactivate
(
self
,
jid
):
q
=
"""INSERT OR REPLACE INTO encryption_state (jid, encryption)
VALUES (?, 0)"""
c
=
self
.
dbConn
.
cursor
()
c
.
execute
(
q
,
(
jid
,
))
self
.
dbConn
.
commit
()
def
is_active
(
self
,
jid
):
q
=
'SELECT encryption FROM encryption_state where jid = ?;'
c
=
self
.
dbConn
.
cursor
()
c
.
execute
(
q
,
(
jid
,
))
result
=
c
.
fetchone
()
if
result
is
None
:
return
False
return
result
[
0
]
def
exist
(
self
,
jid
):
q
=
'SELECT encryption FROM encryption_state where jid = ?;'
c
=
self
.
dbConn
.
cursor
()
c
.
execute
(
q
,
(
jid
,
))
result
=
c
.
fetchone
()
if
result
is
None
:
return
False
else
:
return
True
omemo/backend/liteaxolotlstore.py
View file @
8b63fd9b
This diff is collapsed.
Click to expand it.
omemo/backend/liteidentitykeystore.py
deleted
100644 → 0
View file @
065b3f04
# -*- coding: utf-8 -*-
#
# Copyright 2015 Tarek Galal <tare2.galal@gmail.com>
#
# This file is part of Gajim-OMEMO plugin.
#
# The Gajim-OMEMO plugin is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by the Free
# Software Foundation, either version 3 of the License, or (at your option) any
# later version.
#
# Gajim-OMEMO is distributed in the hope that it will be useful, but WITHOUT ANY
# WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
# A PARTICULAR PURPOSE. See the GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License along with
# the Gajim-OMEMO plugin. If not, see <http://www.gnu.org/licenses/>.
#
from
axolotl.ecc.djbec
import
DjbECPrivateKey
,
DjbECPublicKey
from
axolotl.identitykey
import
IdentityKey
from
axolotl.identitykeypair
import
IdentityKeyPair
from
axolotl.state.identitykeystore
import
IdentityKeyStore
UNDECIDED
=
2
TRUSTED
=
1
UNTRUSTED
=
0
class
LiteIdentityKeyStore
(
IdentityKeyStore
):
def
__init__
(
self
,
dbConn
):
"""
:type dbConn: Connection
"""
self
.
dbConn
=
dbConn
def
getIdentityKeyPair
(
self
):
q
=
"SELECT public_key, private_key FROM identities "
+
\
"WHERE recipient_id = -1"
c
=
self
.
dbConn
.
cursor
()
c
.
execute
(
q
)
result
=
c
.
fetchone
()
publicKey
,
privateKey
=
result
return
IdentityKeyPair
(
IdentityKey
(
DjbECPublicKey
(
publicKey
[
1
:])),
DjbECPrivateKey
(
privateKey
))
def
getLocalRegistrationId
(
self
):
q
=
"SELECT registration_id FROM identities WHERE recipient_id = -1"
c
=
self
.
dbConn
.
cursor
()
c
.
execute
(
q
)
result
=
c
.
fetchone
()
return
result
[
0
]
if
result
else
None
def
storeLocalData
(
self
,
registrationId
,
identityKeyPair
):
q
=
"INSERT INTO identities( "
+
\
"recipient_id, registration_id, public_key, private_key) "
+
\
"VALUES(-1, ?, ?, ?)"
c
=
self
.
dbConn
.
cursor
()
c
.
execute
(
q
,
(
registrationId
,
identityKeyPair
.
getPublicKey
().
getPublicKey
().
serialize
(),
identityKeyPair
.
getPrivateKey
().
serialize
()))
self
.
dbConn
.
commit
()
def
saveIdentity
(
self
,
recipientId
,
identityKey
):
q
=
"INSERT INTO identities (recipient_id, public_key, trust) "
\
"VALUES(?, ?, ?)"
c
=
self
.
dbConn
.
cursor
()
if
not
self
.
getIdentity
(
recipientId
,
identityKey
):
c
.
execute
(
q
,
(
recipientId
,
identityKey
.
getPublicKey
().
serialize
(),
UNDECIDED
))
self
.
dbConn
.
commit
()
def
getIdentity
(
self
,
recipientId
,
identityKey
):
q
=
"SELECT * FROM identities WHERE recipient_id = ? "
\
"AND public_key = ?"
c
=
self
.
dbConn
.
cursor
()
c
.
execute
(
q
,
(
recipientId
,
identityKey
.
getPublicKey
().
serialize
()))
result
=
c
.
fetchone
()
return
result
is
not
None
def
deleteIdentity
(
self
,
recipientId
,
identityKey
):
q
=
"DELETE FROM identities WHERE recipient_id = ? AND public_key = ?"
c
=
self
.
dbConn
.
cursor
()
c
.
execute
(
q
,
(
recipientId
,
identityKey
.
getPublicKey
().
serialize
()))
self
.
dbConn
.
commit
()
def
isTrustedIdentity
(
self
,
recipientId
,
identityKey
):
q
=
"SELECT trust FROM identities WHERE recipient_id = ? "
\
"AND public_key = ?"
c
=
self
.
dbConn
.
cursor
()
c
.
execute
(
q
,
(
recipientId
,
identityKey
.
getPublicKey
().
serialize
()))
result
=
c
.
fetchone
()
states
=
[
UNTRUSTED
,
TRUSTED
,
UNDECIDED
]
if
result
and
result
[
0
]
in
states
:
return
result
[
0
]
else
:
return
True
def
getAllFingerprints
(
self
):
q
=
"SELECT _id, recipient_id, public_key, trust FROM identities "
\
"WHERE recipient_id != -1 ORDER BY recipient_id ASC"
c
=
self
.
dbConn
.
cursor
()
result
=
[]
for
row
in
c
.
execute
(
q
):
result
.
append
((
row
[
0
],
row
[
1
],
row
[
2
],
row
[
3
]))
return
result
def
getFingerprints
(
self
,
jid
):
q
=
"SELECT _id, recipient_id, public_key, trust FROM identities "
\
"WHERE recipient_id =? ORDER BY trust ASC"
c
=
self
.
dbConn
.
cursor
()
result
=
[]
c
.
execute
(
q
,
(
jid
,))
rows
=
c
.
fetchall
()
for
row
in
rows
:
result
.
append
((
row
[
0
],
row
[
1
],
row
[
2
],
row
[
3
]))
return
result
def
getTrustedFingerprints
(
self
,
jid
):
q
=
"SELECT public_key FROM identities WHERE recipient_id = ? AND trust = ?"
c
=
self
.
dbConn
.
cursor
()
result
=
[]
c
.
execute
(
q
,
(
jid
,
TRUSTED
))
rows
=
c
.
fetchall
()
for
row
in
rows
:
result
.
append
(
row
[
0
])
return
result
def
getUndecidedFingerprints
(
self
,
jid
):
q
=
"SELECT trust FROM identities WHERE recipient_id = ? AND trust = ?"
c
=
self
.
dbConn
.
cursor
()
result
=
[]
c
.
execute
(
q
,
(
jid
,
UNDECIDED
))
result
=
c
.
fetchall
()
return
result
def
getNewFingerprints
(
self
,
jid
):
q
=
"SELECT _id FROM identities WHERE shown = 0 AND "
\
"recipient_id = ?"
c
=
self
.
dbConn
.
cursor
()
result
=
[]
for
row
in
c
.
execute
(
q
,
(
jid
,)):
result
.
append
(
row
[
0
])
return
result
def
setShownFingerprints
(
self
,
fingerprints
):
q
=
"UPDATE identities SET shown = 1 WHERE _id IN ({})"
\
.
format
(
', '
.
join
([
'?'
]
*
len
(
fingerprints
)))
c
=
self
.
dbConn
.
cursor
()
c
.
execute
(
q
,
fingerprints
)
self
.
dbConn
.
commit
()
def
setTrust
(
self
,
identityKey
,
trust
):
q
=
"UPDATE identities SET trust = ? WHERE public_key = ?"
c
=
self
.
dbConn
.
cursor
()
c
.
execute
(
q
,
(
trust
,
identityKey
.
getPublicKey
().
serialize
()))
self
.
dbConn
.
commit
()
omemo/backend/liteprekeystore.py
deleted
100644 → 0
View file @
065b3f04
# -*- coding: utf-8 -*-
#
# Copyright 2015 Tarek Galal <tare2.galal@gmail.com>
#
# This file is part of Gajim-OMEMO plugin.
#
# The Gajim-OMEMO plugin is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by the Free
# Software Foundation, either version 3 of the License, or (at your option) any
# later version.
#
# Gajim-OMEMO is distributed in the hope that it will be useful, but WITHOUT ANY
# WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
# A PARTICULAR PURPOSE. See the GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License along with
# the Gajim-OMEMO plugin. If not, see <http://www.gnu.org/licenses/>.
#
from
axolotl.state.prekeyrecord
import
PreKeyRecord
from
axolotl.state.prekeystore
import
PreKeyStore
from
axolotl.util.keyhelper
import
KeyHelper
class
LitePreKeyStore
(
PreKeyStore
):
def
__init__
(
self
,
dbConn
):
"""
:type dbConn: Connection
"""
self
.
dbConn
=
dbConn
def
loadPreKey
(
self
,
preKeyId
):
q
=
"SELECT record FROM prekeys WHERE prekey_id = ?"
cursor
=
self
.
dbConn
.
cursor
()
cursor
.
execute
(
q
,
(
preKeyId
,
))
result
=
cursor
.
fetchone
()
if
not
result
:
raise
Exception
(
"No such prekeyRecord!"
)
return
PreKeyRecord
(
serialized
=
result
[
0
])
def
loadPendingPreKeys
(
self
):
q
=
"SELECT record FROM prekeys"
cursor
=
self
.
dbConn
.
cursor
()
cursor
.
execute
(
q
)
result
=
cursor
.
fetchall
()
return
[
PreKeyRecord
(
serialized
=
r
[
0
])
for
r
in
result
]
def
storePreKey
(
self
,
preKeyId
,
preKeyRecord
):
q
=
"INSERT INTO prekeys (prekey_id, record) VALUES(?,?)"
cursor
=
self
.
dbConn
.
cursor
()
cursor
.
execute
(
q
,
(
preKeyId
,
preKeyRecord
.
serialize
()))
self
.
dbConn
.
commit
()
def
containsPreKey
(
self
,
preKeyId
):
q
=
"SELECT record FROM prekeys WHERE prekey_id = ?"
cursor
=
self
.
dbConn
.
cursor
()
cursor
.
execute
(
q
,
(
preKeyId
,
))
return
cursor
.
fetchone
()
is
not
None
def
removePreKey
(
self
,
preKeyId
):
q
=
"DELETE FROM prekeys WHERE prekey_id = ?"
cursor
=
self
.
dbConn
.
cursor
()
cursor
.
execute
(
q
,
(
preKeyId
,
))
self
.
dbConn
.
commit
()
def
getCurrentPreKeyId
(
self
):
q
=
"SELECT MAX(prekey_id) FROM prekeys"
cursor
=
self
.
dbConn
.
cursor
()
cursor
.
execute
(
q
)
return
cursor
.
fetchone
()[
0
]
def
getPreKeyCount
(
self
):
q
=
"SELECT COUNT(prekey_id) FROM prekeys"
cursor
=
self
.
dbConn
.
cursor
()
cursor
.
execute
(
q
)
return
cursor
.
fetchone
()[
0
]
def
generateNewPreKeys
(
self
,
count
):
startId
=
self
.
getCurrentPreKeyId
()
+
1
preKeys
=
KeyHelper
.
generatePreKeys
(
startId
,
count
)
for
preKey
in
preKeys
:
self
.
storePreKey
(
preKey
.
getId
(),
preKey
)
omemo/backend/litesessionstore.py
deleted
100644 → 0
View file @
065b3f04
# -*- coding: utf-8 -*-
#
# Copyright 2015 Tarek Galal <tare2.galal@gmail.com>
#
# This file is part of Gajim-OMEMO plugin.
#
# The Gajim-OMEMO plugin is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by the Free
# Software Foundation, either version 3 of the License, or (at your option) any
# later version.
#
# Gajim-OMEMO is distributed in the hope that it will be useful, but WITHOUT ANY
# WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
# A PARTICULAR PURPOSE. See the GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License along with
# the Gajim-OMEMO plugin. If not, see <http://www.gnu.org/licenses/>.
#
from
axolotl.state.sessionrecord
import
SessionRecord
from
axolotl.state.sessionstore
import
SessionStore
class
LiteSessionStore
(
SessionStore
):
def
__init__
(
self
,
dbConn
):
"""
:type dbConn: Connection
"""
self
.
dbConn
=
dbConn
def
loadSession
(
self
,
recipientId
,
deviceId
):
q
=
"SELECT record FROM sessions WHERE recipient_id = ? AND device_id = ?"
c
=
self
.
dbConn
.
cursor
()
c
.
execute
(
q
,
(
recipientId
,
deviceId
))
result
=
c
.
fetchone
()
if
result
:
return
SessionRecord
(
serialized
=
result
[
0
])
else
:
return
SessionRecord
()
def
getSubDeviceSessions
(
self
,
recipientId
):
q
=
"SELECT device_id from sessions WHERE recipient_id = ?"
c
=
self
.
dbConn
.
cursor
()
c
.
execute
(
q
,
(
recipientId
,
))
result
=
c
.
fetchall
()
deviceIds
=
[
r
[
0
]
for
r
in
result
]
return
deviceIds
def
getJidFromDevice
(
self
,
device_id
):
q
=
"SELECT recipient_id from sessions WHERE device_id = ?"
c
=
self
.
dbConn
.
cursor
()
c
.
execute
(
q
,
(
device_id
,
))
result
=
c
.
fetchone
()
return
result
[
0
].
decode
(
'utf-8'
)
if
result
else
None
def
getActiveDeviceTuples
(
self
):
q
=
"SELECT recipient_id, device_id FROM sessions WHERE active = 1"
c
=
self
.
dbConn
.
cursor
()
result
=
[]
for
row
in
c
.
execute
(
q
):
result
.
append
((
row
[
0
].
decode
(
'utf-8'
),
row
[
1
]))
return
result
def
storeSession
(
self
,
recipientId
,
deviceId
,
sessionRecord
):
self
.
deleteSession
(
recipientId
,
deviceId
)
q
=
"INSERT INTO sessions(recipient_id, device_id, record) VALUES(?,?,?)"
c
=
self
.
dbConn
.
cursor
()
c
.
execute
(
q
,
(
recipientId
,
deviceId
,
sessionRecord
.
serialize
()))
self
.
dbConn
.
commit
()
def
containsSession
(
self
,
recipientId
,
deviceId
):
q
=
"SELECT record FROM sessions WHERE recipient_id = ? AND device_id = ?"
c
=
self
.
dbConn
.
cursor
()
c
.
execute
(
q
,
(
recipientId
,
deviceId
))
result
=
c
.
fetchone
()
return
result
is
not
None
def
deleteSession
(
self
,
recipientId
,
deviceId
):
q
=
"DELETE FROM sessions WHERE recipient_id = ? AND device_id = ?"
self
.
dbConn
.
cursor
().
execute
(
q
,
(
recipientId
,
deviceId
))
self
.
dbConn
.
commit
()
def
deleteAllSessions
(
self
,
recipientId
):
q
=
"DELETE FROM sessions WHERE recipient_id = ?"
self
.
dbConn
.
cursor
().
execute
(
q
,
(
recipientId
,
))
self
.
dbConn
.
commit
()
def
getAllSessions
(
self
):
q
=
"SELECT _id, recipient_id, device_id, record, active from sessions"
c
=
self
.
dbConn
.
cursor
()
result
=
[]
for
row
in
c
.
execute
(
q
):
result
.
append
((
row
[
0
],
row
[
1
].
decode
(
'utf-8'
),
row
[
2
],
row
[
3
],
row
[
4
]))
return
result
def
getSessionsFromJid
(
self
,
recipientId
):
q
=
"SELECT _id, recipient_id, device_id, record, active from sessions"
\
" WHERE recipient_id = ?"
c
=
self
.
dbConn
.
cursor
()
result
=
[]
for
row
in
c
.
execute
(
q
,
(
recipientId
,)):
result
.
append
((
row
[
0
],
row
[
1
].
decode
(
'utf-8'
),
row
[
2
],
row
[
3
],
row
[
4
]))
return
result
def
getSessionsFromJids
(
self
,
recipientId
):
q
=
"SELECT _id, recipient_id, device_id, record, active from sessions"
\
" WHERE recipient_id IN ({})"
\
.
format
(
', '
.
join
([
'?'
]
*
len
(
recipientId
)))
c
=
self
.
dbConn
.
cursor
()
result
=
[]
for
row
in
c
.
execute
(
q
,
recipientId
):
result
.
append
((
row
[
0
],
row
[
1
].
decode
(
'utf-8'
),
row
[
2
],
row
[
3
],
row
[
4
]))
return
result
def
setActiveState
(
self
,
deviceList
,
jid
):
c
=
self
.
dbConn
.
cursor
()
q
=
"UPDATE sessions SET active = {} "
\
"WHERE recipient_id = '{}' AND device_id IN ({})"
\
.
format
(
1
,
jid
,
', '
.
join
([
'?'
]
*
len
(
deviceList
)))
c
.
execute
(
q
,
deviceList
)
q
=
"UPDATE sessions SET active = {} "
\
"WHERE recipient_id = '{}' AND device_id NOT IN ({})"
\
.
format
(
0
,
jid
,
', '
.
join
([
'?'
]
*
len
(
deviceList
)))
c
.
execute
(
q
,
deviceList
)
self
.
dbConn
.
commit
()
def
getInactiveSessionsKeys
(
self
,
recipientId
):
q
=
"SELECT record FROM sessions WHERE active = 0 AND recipient_id = ?"
c
=
self
.
dbConn
.
cursor
()
result
=
[]
for
row
in
c
.
execute
(
q
,
(
recipientId
,)):
public_key
=
(
SessionRecord
(
serialized
=
row
[
0
]).
getSessionState
().
getRemoteIdentityKey
().
getPublicKey
())
result
.
append
(
public_key
.
serialize
())
return
result
omemo/backend/litesignedprekeystore.py
deleted
100644 → 0
View file @
065b3f04
# -*- coding: utf-8 -*-
#
# Copyright 2015 Tarek Galal <tare2.galal@gmail.com>
#
# This file is part of Gajim-OMEMO plugin.
#
# The Gajim-OMEMO plugin is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by the Free
# Software Foundation, either version 3 of the License, or (at your option) any
# later version.
#
# Gajim-OMEMO is distributed in the hope that it will be useful, but WITHOUT ANY
# WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
# A PARTICULAR PURPOSE. See the GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License along with
# the Gajim-OMEMO plugin. If not, see <http://www.gnu.org/licenses/>.
#
from
axolotl.invalidkeyidexception
import
InvalidKeyIdException
from
axolotl.state.signedprekeyrecord
import
SignedPreKeyRecord
from
axolotl.state.signedprekeystore
import
SignedPreKeyStore
from
axolotl.util.medium
import
Medium
class
LiteSignedPreKeyStore
(
SignedPreKeyStore
):
def
__init__
(
self
,
dbConn
):
"""
:type dbConn: Connection
"""
self
.
dbConn
=
dbConn
def
loadSignedPreKey
(
self
,
signedPreKeyId
):
q
=
"SELECT record FROM signed_prekeys WHERE prekey_id = ?"
cursor
=
self
.
dbConn
.
cursor
()
cursor
.
execute
(
q
,
(
signedPreKeyId
,
))
result
=
cursor
.
fetchone
()
if
not
result
:
raise
InvalidKeyIdException
(
"No such signedprekeyrecord! %s "
%
signedPreKeyId
)
return
SignedPreKeyRecord
(
serialized
=
result
[
0
])
def
loadSignedPreKeys
(
self
):
q
=
"SELECT record FROM signed_prekeys"
cursor
=
self
.
dbConn
.
cursor
()
cursor
.
execute
(
q
,
)
result
=
cursor
.
fetchall
()
results
=
[]
for
row
in
result
:
results
.
append
(
SignedPreKeyRecord
(
serialized
=
row
[
0
]))
return
results
def
storeSignedPreKey
(
self
,
signedPreKeyId
,
signedPreKeyRecord
):
q
=
"INSERT INTO signed_prekeys (prekey_id, record) VALUES(?,?)"
cursor
=
self
.
dbConn
.
cursor
()
cursor
.
execute
(
q
,
(
signedPreKeyId
,
signedPreKeyRecord
.
serialize
()))
self
.
dbConn
.
commit
()
def
containsSignedPreKey
(
self
,
signedPreKeyId
):
q
=
"SELECT record FROM signed_prekeys WHERE prekey_id = ?"
cursor
=
self
.
dbConn
.
cursor
()
cursor
.
execute
(
q
,
(
signedPreKeyId
,
))
return
cursor
.
fetchone
()
is
not
None
def
removeSignedPreKey
(
self
,
signedPreKeyId
):
q
=
"DELETE FROM signed_prekeys WHERE prekey_id = ?"
cursor
=
self
.
dbConn
.
cursor
()
cursor
.
execute
(
q
,
(
signedPreKeyId
,
))
self
.
dbConn
.
commit
()
def
getNextSignedPreKeyId
(
self
):
result
=
self
.
getCurrentSignedPreKeyId
()
if
not
result
:
return
1
# StartId if no SignedPreKeys exist
else
:
return
(
result
%
(
Medium
.
MAX_VALUE
-
1
))
+
1
def
getCurrentSignedPreKeyId
(
self
):
q
=
"SELECT MAX(prekey_id) FROM signed_prekeys"
cursor
=
self
.
dbConn
.
cursor
()
cursor
.
execute
(
q
)
result
=
cursor
.
fetchone
()
if
not
result
:
return
None
else
:
return
result
[
0
]
def
getSignedPreKeyTimestamp
(
self
,
signedPreKeyId
):
q
=
"SELECT strftime('%s', timestamp) FROM "
\
"signed_prekeys WHERE prekey_id = ?"
cursor
=
self
.
dbConn
.
cursor
()
cursor
.
execute
(
q
,
(
signedPreKeyId
,
))
result
=
cursor
.
fetchone
()
if
not
result
:
raise
InvalidKeyIdException
(
"No such signedprekeyrecord! %s "
%
signedPreKeyId
)
return
result
[
0
]
def
removeOldSignedPreKeys
(
self
,
timestamp
):
q
=
"DELETE FROM signed_prekeys "
\
"WHERE timestamp < datetime(?, 'unixepoch')"
cursor
=
self
.
dbConn
.
cursor
()
cursor
.
execute
(
q
,
(
timestamp
,
))
self
.
dbConn
.
commit
()
omemo/backend/sql.py
deleted