diff -uNr a/oauth2client/_pure_python_crypt.py b/oauth2client/_pure_python_crypt.py

--- a/oauth2client/_pure_python_crypt.py	2016-10-14 19:53:53.000000000 +0200

+++ b/oauth2client/_pure_python_crypt.py	2018-06-21 15:40:25.216478384 +0200

@@ -23,7 +23,10 @@

 from pyasn1_modules import pem

 from pyasn1_modules.rfc2459 import Certificate

 from pyasn1_modules.rfc5208 import PrivateKeyInfo

-import rsa

+from cryptography.hazmat.primitives import serialization, hashes

+from cryptography.hazmat.primitives.asymmetric import padding

+from cryptography import x509

+from cryptography.hazmat.backends import default_backend

 import six

 from oauth2client import _helpers

@@ -70,7 +73,8 @@

     """

     def __init__(self, pubkey):

-        self._pubkey = pubkey

+        self._pubkey = serialization.load_pem_public_key(pubkey,

+            backend=default_backend())

     def verify(self, message, signature):

         """Verifies a message against a signature.

@@ -87,8 +91,9 @@

         """

         message = _helpers._to_bytes(message, encoding='utf-8')

         try:

-            return rsa.pkcs1.verify(message, signature, self._pubkey)

-        except (ValueError, rsa.pkcs1.VerificationError):

+            return self._pubkey.verify(signature, message, padding.PKCS1v15(),

+                hashes.SHA256())

+        except (ValueError, TypeError, InvalidSignature):

             return False

     @classmethod

@@ -112,16 +117,18 @@

         """

         key_pem = _helpers._to_bytes(key_pem)

         if is_x509_cert:

-            der = rsa.pem.load_pem(key_pem, 'CERTIFICATE')

+            der = x509.load_pem_x509_certificate(pem_data, default_backend())

             asn1_cert, remaining = decoder.decode(der, asn1Spec=Certificate())

             if remaining != b'':

                 raise ValueError('Unused bytes', remaining)

             cert_info = asn1_cert['tbsCertificate']['subjectPublicKeyInfo']

             key_bytes = _bit_list_to_bytes(cert_info['subjectPublicKey'])

-            pubkey = rsa.PublicKey.load_pkcs1(key_bytes, 'DER')

+            pubkey = serialization.load_der_public_key(decoded_key,

+                backend=default_backend())

         else:

-            pubkey = rsa.PublicKey.load_pkcs1(key_pem, 'PEM')

+            pubkey = serialization.load_pem_public_key(decoded_key,

+                backend=default_backend())

         return cls(pubkey)

@@ -134,6 +141,8 @@

     def __init__(self, pkey):

         self._key = pkey

+        self._pubkey = serialization.load_pem_private_key(pkey,

+            backend=default_backend())

     def sign(self, message):

         """Signs a message.

@@ -145,7 +154,7 @@

             string, The signature of the message for the given key.

         """

         message = _helpers._to_bytes(message, encoding='utf-8')

-        return rsa.pkcs1.sign(message, self._key, 'SHA-256')

+        return self._key.sign(message, padding.PKCS1v15(), hashes.SHA256())

     @classmethod

     def from_string(cls, key, password='notasecret'):

@@ -168,16 +177,19 @@

             six.StringIO(key), _PKCS1_MARKER, _PKCS8_MARKER)

         if marker_id == 0:

-            pkey = rsa.key.PrivateKey.load_pkcs1(key_bytes,

-                                                 format='DER')

+            pkey = serialization.load_der_private_key(

+                key_bytes, password=None,

+                backend=default_backend())

+

         elif marker_id == 1:

             key_info, remaining = decoder.decode(

                 key_bytes, asn1Spec=_PKCS8_SPEC)

             if remaining != b'':

                 raise ValueError('Unused bytes', remaining)

             pkey_info = key_info.getComponentByName('privateKey')

-            pkey = rsa.key.PrivateKey.load_pkcs1(pkey_info.asOctets(),

-                                                 format='DER')

+            pkey = serialization.load_der_private_key(

+                pkey_info.asOctets(), password=None,

+                backend=default_backend())

         else:

             raise ValueError('No key could be detected.')