add support for code challenge

Adapter.php

@@ -121,6 +121,9 @@ public function upgradeStorage($storageId)
         if ($oldStorage->hasAuthorizationState($service)) {
             $newStorage->storeAuthorizationState($service, $oldStorage->retrieveAuthorizationState($service));
         }
+        if ($oldStorage->hasCodeVerifier($service)) {
+            $newStorage->storeCodeVerifier($service, $oldStorage->retrieveCodeVerifier($service));
+        }
 
         // fixme invalidate current oauth object? reinitialize it?
     }

Storage.php

@@ -149,4 +149,51 @@ public function clearAllAuthorizationStates()
 
         return $this;
     }
+
+    /** @inheritDoc */
+    public function storeCodeVerifier($service, $verifier)
+    {
+        $data = $this->loadServiceFile($service);
+        $data['verifier'] = $verifier;
+        $this->saveServiceFile($service, $data);
+        return $this;
+    }
+
+    /** @inheritDoc */
+    public function hasCodeVerifier($service)
+    {
+        $data = $this->loadServiceFile($service);
+        return isset($data['verifier']);
+    }
+
+    /**
+     * @inheritDoc
+     * @throws TokenNotFoundException
+     */
+    public function retrieveCodeVerifier($service)
+    {
+        $data = $this->loadServiceFile($service);
+        if (!isset($data['verifier'])) {
+            throw new TokenNotFoundException('No code verifier found in storage');
+        }
+        return $data['verifier'];
+    }
+
+    /** @inheritDoc */
+    public function clearCodeVerifier($service)
+    {
+        $data = $this->loadServiceFile($service);
+        if (isset($data['verifier'])) unset($data['verifier']);
+        $this->saveServiceFile($service, $data);
+
+        return $this;
+    }
+
+    /** @inheritDoc */
+    public function clearAllCodeVerifiers()
+    {
+        // TODO: Implement clearAllCodeVerifiers() method.
+
+        return $this;
+    }
 }

vendor/lusitanian/oauth/src/OAuth/Common/Storage/Exception/CodeVerifierNotFoundException.php

@@ -0,0 +1,10 @@
+<?php
+
+namespace OAuth\Common\Storage\Exception;
+
+/**
+ * Exception thrown when a code verifier is not found in storage.
+ */
+class CodeVerifierNotFoundException extends StorageException
+{
+}

vendor/lusitanian/oauth/src/OAuth/Common/Storage/Memory.php

@@ -5,6 +5,7 @@
 use OAuth\Common\Token\TokenInterface;
 use OAuth\Common\Storage\Exception\TokenNotFoundException;
 use OAuth\Common\Storage\Exception\AuthorizationStateNotFoundException;
+use OAuth\Common\Storage\Exception\CodeVerifierNotFoundException;
 
 /*
  * Stores a token in-memory only (destroyed at end of script execution).
@@ -21,10 +22,16 @@ class Memory implements TokenStorageInterface
      */
     protected $states;
 
+    /**
+     * @var array
+     */
+    protected $verifiers;
+
     public function __construct()
     {
         $this->tokens = array();
         $this->states = array();
+        $this->verifiers = array();
     }
 
     /**
@@ -136,4 +143,59 @@ public function clearAllAuthorizationStates()
         // allow chaining
         return $this;
     }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function retrieveCodeVerifier($service)
+    {
+        if ($this->hasCodeVerifier($service)) {
+            return $this->verifiers[$service];
+        }
+
+        throw new CodeVerifierNotFoundException('code verifier not stored');
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function storeCodeVerifier($service, $verifier)
+    {
+        $this->verifiers[$service] = $verifier;
+
+        // allow chaining
+        return $this;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function hasCodeVerifier($service)
+    {
+        return isset($this->verifiers[$service]) && null !== $this->verifiers[$service];
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function clearCodeVerifier($service)
+    {
+        if (array_key_exists($service, $this->verifiers)) {
+            unset($this->verifiers[$service]);
+        }
+
+        // allow chaining
+        return $this;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function clearAllCodeVerifiers()
+    {
+        $this->verifiers = array();
+
+        // allow chaining
+        return $this;
+    }
 }

vendor/lusitanian/oauth/src/OAuth/Common/Storage/Redis.php

@@ -5,6 +5,7 @@
 use OAuth\Common\Token\TokenInterface;
 use OAuth\Common\Storage\Exception\TokenNotFoundException;
 use OAuth\Common\Storage\Exception\AuthorizationStateNotFoundException;
+use OAuth\Common\Storage\Exception\CodeVerifierNotFoundException;
 use Predis\Client as Predis;
 
 /*
@@ -19,6 +20,11 @@ class Redis implements TokenStorageInterface
 
     protected $stateKey;
 
+    /**
+     * @var string
+     */
+    protected $verifierKey;
+
     /**
      * @var object|\Redis
      */
@@ -34,18 +40,26 @@ class Redis implements TokenStorageInterface
      */
     protected $cachedStates;
 
+    /**
+     * @var object
+     */
+    protected $cachedVerifiers;
+
     /**
      * @param Predis $redis An instantiated and connected redis client
      * @param string $key The key to store the token under in redis
      * @param string $stateKey The key to store the state under in redis.
+     * @param string $verifierKey The key to store the verifier under in redis.
      */
-    public function __construct(Predis $redis, $key, $stateKey)
+    public function __construct(Predis $redis, $key, $stateKey, $verifierKey)
     {
         $this->redis = $redis;
         $this->key = $key;
         $this->stateKey = $stateKey;
+        $this->verifierKey = $verifierKey;
         $this->cachedTokens = array();
         $this->cachedStates = array();
+        $this->cachedVerifiers = array();
     }
 
     /**
@@ -212,6 +226,88 @@ function ($pipe) use ($keys, $me) {
         return $this;
     }
 
+    /**
+     * {@inheritDoc}
+     */
+    public function retrieveCodeVerifier($service)
+    {
+        if (!$this->hasCodeVerifier($service)) {
+            throw new CodeVerifierNotFoundException('CodeVerifier not found in redis');
+        }
+
+        if (isset($this->cachedVerifiers[$service])) {
+            return $this->cachedVerifiers[$service];
+        }
+
+        $val = $this->redis->hget($this->verifierKey, $service);
+
+        return $this->cachedVerifiers[$service] = $val;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function storeCodeVerifier($service, $verifier)
+    {
+        // (over)write the token
+        $this->redis->hset($this->verifierKey, $service, $verifier);
+        $this->cachedVerifiers[$service] = $verifier;
+
+        // allow chaining
+        return $this;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function hasCodeVerifier($service)
+    {
+        if (isset($this->cachedVerifiers[$service])
+            && null !== $this->cachedVerifiers[$service]
+        ) {
+            return true;
+        }
+
+        return $this->redis->hexists($this->verifierKey, $service);
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function clearCodeVerifier($service)
+    {
+        $this->redis->hdel($this->verifierKey, $service);
+        unset($this->cachedVerifiers[$service]);
+
+        // allow chaining
+        return $this;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function clearAllCodeVerifiers()
+    {
+        // memory
+        $this->cachedVerifiers = array();
+
+        // redis
+        $keys = $this->redis->hkeys($this->verifierKey);
+        $me = $this; // 5.3 compat
+
+        // pipeline for performance
+        $this->redis->pipeline(
+            function ($pipe) use ($keys, $me) {
+                foreach ($keys as $k) {
+                    $pipe->hdel($me->getKey(), $k);
+                }
+            }
+        );
+
+        // allow chaining
+        return $this;
+    }
+
     /**
      * @return Predis $redis
      */