mirror/emacs
1
0
Fork 0
mirror of https://git.savannah.gnu.org/git/emacs.git synced 2025-01-18 18:05:07 +00:00
Code Issues Releases Activity

Remove the base64 Face header repadding in Gnus

Browse Source 
* lisp/gnus/gnus-fun.el (gnus-convert-face-to-png): Remove call.

* lisp/gnus/gnus-util.el (gnus-base64-repad): Remove.
This commit is contained in:
Alex Bochannek 2021-05-26 23:54:59 +02:00 committed by Lars Ingebrigtsen
parent c4e8d1dbe2
commit 777d784d8f
3 changed files with 5 additions and 98 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
lisp/gnus/gnus-fun.el
View File

@ -206,12 +206,11 @@ different input formats."
(defun gnus-convert-face-to-png (face)
"Convert FACE (which is base64-encoded) to a PNG.
The PNG is returned as a string."
(let ((face (gnus-base64-repad face nil nil t)))
(mm-with-unibyte-buffer
(insert face)
(ignore-errors
(base64-decode-region (point-min) (point-max)))
(buffer-string))))
(mm-with-unibyte-buffer
(insert face)
(ignore-errors
(base64-decode-region (point-min) (point-max)))
(buffer-string)))
;;;###autoload
(defun gnus-convert-png-to-face (file)

55
lisp/gnus/gnus-util.el
View File

@ -1291,61 +1291,6 @@ forbidden in URL encoding."
(setq tmp (concat tmp str))
tmp))
(defun gnus-base64-repad (str &optional reject-newlines line-length no-check)
"Take a base 64-encoded string and return it padded correctly.
Existing padding is ignored.
If any combination of CR and LF characters are present and
REJECT-NEWLINES is nil, remove them; otherwise raise an error.
If LINE-LENGTH is set and the string (or any line in the string
if REJECT-NEWLINES is nil) is longer than that number, raise an
error. Common line length for input characters are 76 plus CRLF
\(RFC 2045 MIME), 64 plus CRLF (RFC 1421 PEM), and 1000 including
CRLF (RFC 5321 SMTP).
If NOCHECK, don't check anything, but just repad."
;; RFC 4648 specifies that:
;; - three 8-bit inputs make up a 24-bit group
;; - the 24-bit group is broken up into four 6-bit values
;; - each 6-bit value is mapped to one character of the base 64 alphabet
;; - if the final 24-bit quantum is filled with only 8 bits the output
;; will be two base 64 characters followed by two "=" padding characters
;; - if the final 24-bit quantum is filled with only 16 bits the output
;; will be three base 64 character followed by one "=" padding character
;;
;; RFC 4648 section 3 considerations:
;; - if reject-newlines is nil (default), concatenate multi-line
;; input (3.1, 3.3)
;; - if line-length is set, error on input exceeding the limit (3.1)
;; - reject characters outside base encoding (3.3, also section 12)
;;
;; RFC 5322 section 2.2.3 consideration:
;; Because base 64-encoded strings can appear in long header fields, remove
;; folding whitespace while still observing the RFC 4648 decisions above.
(when no-check
(setq str (replace-regexp-in-string "[\n\r \t]+" "" str)));
(let ((splitstr (split-string str "[ \t]*[\r\n]+[ \t]?" t)))
(when (and reject-newlines (> (length splitstr) 1))
(error "Invalid Base64 string"))
(dolist (substr splitstr)
(when (and line-length (> (length substr) line-length))
(error "Base64 string exceeds line-length"))
(when (string-match "[^A-Za-z0-9+/=]" substr)
(error "Invalid Base64 string")))
(let* ((str (string-join splitstr))
(len (length str)))
(when (string-match "=" str)
(setq len (match-beginning 0)))
(concat
(substring str 0 len)
(make-string (/
(- 24
(pcase (mod (* len 6) 24)
(`0 24)
(n n)))
6)
?=)))))
(defun gnus-make-predicate (spec)
"Transform SPEC into a function that can be called.
SPEC is a predicate specifier that contains stuff like `or', `and',

37
test/lisp/gnus/gnus-util-tests.el
View File

@ -132,41 +132,4 @@
(should (equal '("1") (gnus-setdiff '(2 "1" 2) '(2))))
(should (equal '("1" "1") (gnus-setdiff '(2 "1" 2 "1") '(2)))))
(ert-deftest gnus-base64-repad ()
(should-error (gnus-base64-repad 1)
:type 'wrong-type-argument)
;; RFC4648 test vectors
(should (equal "" (gnus-base64-repad "")))
(should (equal "Zg==" (gnus-base64-repad "Zg==")))
(should (equal "Zm8=" (gnus-base64-repad "Zm8=")))
(should (equal "Zm9v" (gnus-base64-repad "Zm9v")))
(should (equal "Zm9vYg==" (gnus-base64-repad "Zm9vYg==")))
(should (equal "Zm9vYmE=" (gnus-base64-repad "Zm9vYmE=")))
(should (equal "Zm9vYmFy" (gnus-base64-repad "Zm9vYmFy")))
(should (equal "Zm8=" (gnus-base64-repad "Zm8")))
(should (equal "Zg==" (gnus-base64-repad "Zg")))
(should (equal "Zg==" (gnus-base64-repad "Zg====")))
(should-error (gnus-base64-repad " ")
:type 'error)
(should-error (gnus-base64-repad "Zg== ")
:type 'error)
(should-error (gnus-base64-repad "Z?\x00g==")
:type 'error)
;; line-length
(should-error (gnus-base64-repad "Zg====" nil 4)
:type 'error)
;; reject-newlines
(should-error (gnus-base64-repad "Zm9v\r\nYmFy" t)
:type 'error)
(should (equal "Zm9vYmFy" (gnus-base64-repad "Zm9vYmFy" t)))
(should (equal "Zm9vYmFy" (gnus-base64-repad "Zm9v\r\nYmFy")))
(should (equal "Zm9vYmFy" (gnus-base64-repad "Zm9v\r\nYmFy\n")))
(should (equal "Zm9vYmFy" (gnus-base64-repad "Zm9v\r\n YmFy\r\n")))
(should (equal "Zm9vYmFy" (gnus-base64-repad "Zm9v \r\n\tYmFy")))
(should-error (gnus-base64-repad "Zm9v\r\nYmFy" nil 3)
:type 'error))
;;; gnustest-gnus-util.el ends here