diff --git a/README.txt b/README.txt
index 9a32668..68d16bf 100644
--- a/README.txt
+++ b/README.txt
@@ -18,8 +18,8 @@
                             ==========
 
 Apache Rat is developed by the Apache Creadur project of the Apache Software
-Foundation. Join us at http://creadur.apache.org and read more about Apache Rat
-at http://creadur.apache.org/rat.
+Foundation. Join us at https://creadur.apache.org and read more about Apache Rat
+at https://creadur.apache.org/rat.
 
 Release Audit Tool (Rat) is a tool to improve accuracy and efficiency when checking
 releases. It is heuristic in nature: making guesses about possible problems. It
@@ -41,7 +41,7 @@
 
 Rat includes a task library for Ant 1.7. This allows Rat reports to be run against
 a wide variety of resources. See ant-task-examples.xml. To use the Ant tasks,
-Apache Ant 1.7 is required. See http://ant.apache.org/.
+Apache Ant 1.7 is required. See https://ant.apache.org/.
 
 For Maven builds, the plugin is recommended.
 
diff --git a/RELEASE-NOTES.txt b/RELEASE-NOTES.txt
index 953b801..4f7a1cd 100644
--- a/RELEASE-NOTES.txt
+++ b/RELEASE-NOTES.txt
@@ -59,9 +59,9 @@
 o RAT-200:  Upgrade ASF parent POM to 17.
 
 
-Historical list of changes: http://creadur.apache.org/rat/changes-report.html
+Historical list of changes: https://creadur.apache.org/rat/changes-report.html
 
 For complete information on Apache Creadur Rat, including instructions on how to submit bug reports,
 patches, or suggestions for improvement, see the Apache Apache Creadur Rat website:
 
-http://creadur.apache.org/rat/
+https://creadur.apache.org/rat/
diff --git a/RELEASE_NOTES.txt b/RELEASE_NOTES.txt
index 7f7d1fc..0f8c90f 100644
--- a/RELEASE_NOTES.txt
+++ b/RELEASE_NOTES.txt
@@ -4,7 +4,7 @@
  * We now require Maven 3.0.5+ to build Rat, but as before we only require
    Maven 2.2.1+ if you want to use Rat in your own Maven projects.
  * We've integrated Rat into the ASF Jenkins to ensure continuous builds with various JDK versions. 
- * Issues resolved (see http://issues.apache.org/jira):
+ * Issues resolved (see https://issues.apache.org/jira):
    Bug
     * [RAT-158] - Fix SAX-Parser warning by explicitly excluding xerces in Doxia 1.2.
                   (thanks to Hervé Boutemy)
@@ -65,7 +65,7 @@
    fixed build/CI environment to reflect and ensure that.
  * Fixed Javadoc warnings during build, upgraded Maven Plugin Plugin to avoid
    warnings in generated code (https://jira.codehaus.org/browse/MPLUGIN-237)
- * Issues resolved (see http://issues.apache.org/jira):
+ * Issues resolved (see https://issues.apache.org/jira):
    Bug
     * [RAT-135] - addLicenseHeaders is missing a space on license header.
     * [RAT-144] - AbstractRatMojo String constant arrays should be private
@@ -90,7 +90,7 @@
 The main change is RAT-138 - Rat 0.9 could run much slower than 0.8 on some input.
 
  * Simpler binary archive
- * Issues resolved (see http://issues.apache.org/jira):
+ * Issues resolved (see https://issues.apache.org/jira):
    * Bugs fixed:
      * [RAT-137] Website shows incorrect Maven goals in some pages
      * [RAT-128] Use the proper name for the Apache License
@@ -110,7 +110,7 @@
  * The Antlib contains a new matcher type that allows matching on the
    full text of the license rather than a single line.
  * Support automatic addition of license headers to svg files.
- * Issues Resolved (see http://issues.apache.org/jira):
+ * Issues Resolved (see https://issues.apache.org/jira):
    * Bugs Fixed:
      * [RAT-3]   - Incorrect alignment of file contents
      * [RAT-102] - typo in pom.xml / field description
@@ -148,7 +148,7 @@
  * Some website fixes
  * The Antlib and Maven plugins now provide simpler ways to detect
    licenses not directly supported by Rat.
- * Issues Resolved (see http://issues.apache.org/jira):
+ * Issues Resolved (see https://issues.apache.org/jira):
   * Bug:
     * RAT-86 CLI doesn't allow adding of licenses unless a custom
       stylesheet has been specified
@@ -184,7 +184,7 @@
 Rat 0.7
 =======
  * Some website fixes
- * Issues Resolved (see http://issues.apache.org/jira):
+ * Issues Resolved (see https://issues.apache.org/jira):
   * Bug:
     * RAT-62 Some of Rat's own files missing License Headers
     * RAT-63 ant-task-examples.xml has an wrong uri in the -typedef ant target
@@ -206,7 +206,7 @@
  * Comprehend PEM, CRL file endings
  * Added reporting capability to recursive rat script
  * Moved to the Incubator@Apache
- * Issues Resolved (see http://issues.apache.org/jira):
+ * Issues Resolved (see https://issues.apache.org/jira):
   * Bug:
     * RAT-3 Incorrect alignment of file contents
     * RAT-11 Incorrect number of unnapproved licences reported
diff --git a/ant-task-examples.xml b/ant-task-examples.xml
index ea365e9..da80181 100644
--- a/ant-task-examples.xml
+++ b/ant-task-examples.xml
@@ -74,7 +74,7 @@
   <target name="url" depends="-taskdef"
     description="runs the task on the ASF's homepage">
     <rat:report xmlns:rat="antlib:org.apache.rat.anttasks">
-      <url url="http://www.apache.org/"/>
+      <url url="https://www.apache.org/"/>
     </rat:report>
   </target>
 
diff --git a/apache-rat-api/src/main/java/org/apache/rat/api/domain/LicenseFamily.java b/apache-rat-api/src/main/java/org/apache/rat/api/domain/LicenseFamily.java
index 94592bc..187b7aa 100644
--- a/apache-rat-api/src/main/java/org/apache/rat/api/domain/LicenseFamily.java
+++ b/apache-rat-api/src/main/java/org/apache/rat/api/domain/LicenseFamily.java
@@ -22,7 +22,7 @@
  * Licenses are grouped into families. Each family has similar legal semantics,
  * though some small details may differ.
  * <p>
- * For example, the <a href='http://opensource.org/licenses/BSD-3-Clause'>3
+ * For example, the <a href='https://opensource.org/licenses/BSD-3-Clause'>3
  * clause BSD license</a> is in a family where members differ by &lt;OWNER&gt;,
  * &lt;ORGANIZATION&gt; and &lt;YEAR&gt; parameters.
  * 
diff --git a/apache-rat-core/src/main/java/org/apache/rat/analysis/license/AppliedApacheSoftwareLicense20.java b/apache-rat-core/src/main/java/org/apache/rat/analysis/license/AppliedApacheSoftwareLicense20.java
index c2250d1..7d0c1ae 100644
--- a/apache-rat-core/src/main/java/org/apache/rat/analysis/license/AppliedApacheSoftwareLicense20.java
+++ b/apache-rat-core/src/main/java/org/apache/rat/analysis/license/AppliedApacheSoftwareLicense20.java
@@ -24,7 +24,7 @@
 
 /**
  * Matches an applied AL 2.0 License header, including a <em>required</em>
- * initial copyright header line, conforming the <a href="http://apache.org/licenses/LICENSE-2.0.html#apply">template</a>
+ * initial copyright header line, conforming the <a href="https://apache.org/licenses/LICENSE-2.0.html#apply">template</a>
  * from the AL 2.0 license itself.
  *
  * @since Rat 0.9
diff --git a/apache-rat-core/src/main/java/org/apache/rat/document/impl/guesser/BinaryGuesser.java b/apache-rat-core/src/main/java/org/apache/rat/document/impl/guesser/BinaryGuesser.java
index 5b0c0c2..1d669bb 100644
--- a/apache-rat-core/src/main/java/org/apache/rat/document/impl/guesser/BinaryGuesser.java
+++ b/apache-rat-core/src/main/java/org/apache/rat/document/impl/guesser/BinaryGuesser.java
@@ -269,7 +269,7 @@
     };
     
     /**
-     * Based on http://www.apache.org/dev/svn-eol-style.txt
+     * Based on https://www.apache.org/dev/svn-eol-style.txt
      */
     private static final String[] NON_BINARY_EXTENSIONS = {
             "AART",
diff --git a/apache-rat-core/src/site/apt/index.apt.vm b/apache-rat-core/src/site/apt/index.apt.vm
index 770b109..1e64387 100644
--- a/apache-rat-core/src/site/apt/index.apt.vm
+++ b/apache-rat-core/src/site/apt/index.apt.vm
@@ -23,8 +23,8 @@
 
  Rat audits software distributions, with a special interest in headers.
  If this isn't quite what you're looking for then take a look at the
- other products developed by {{{http://creadur.apache.org}Apache Creadur}},
- including {{{http://creadur.apache.org/whisker}Apache Whisker}} which audits
+ other products developed by {{{https://creadur.apache.org}Apache Creadur}},
+ including {{{https://creadur.apache.org/whisker}Apache Whisker}} which audits
  and generates legal (for example <<<LICENSE>>>) documents for
  complex software distributions.
 
@@ -38,11 +38,11 @@
 *----------+--------------+----------------+
  <<Runs Rat via>> | <<Requires>>     | <<Module>>       |
 *----------+--------------+----------------+
- An Ant task | {{{http://ant.apache.org}Apache Ant}}     | {{{../apache-rat-tasks}apache-rat-tasks}}      |
+ An Ant task | {{{https://ant.apache.org}Apache Ant}}     | {{{../apache-rat-tasks}apache-rat-tasks}}      |
 *----------+--------------+----------------+
  The command line | Java\u00ae     | {{{../apache-rat}apache-rat}}       |
 *----------+--------------+----------------+
- A Maven plugin | {{{http://maven.apache.org}Apache Maven}}     | {{{../apache-rat-plugin}apache-rat-plugin}}       |
+ A Maven plugin | {{{https://maven.apache.org}Apache Maven}}     | {{{../apache-rat-plugin}apache-rat-plugin}}       |
 *----------+--------------+----------------+
 <<Modules that run Rat>>
 
@@ -57,13 +57,13 @@
 
  Read the JavaDocs {{{./apidocs/index.html}here}}.
 
- Check out with {{{http://subversion.apache.org}Subversion}}
+ Check out with {{{https://subversion.apache.org}Subversion}}
 
 +------------------------------------------+
-svn co http://svn.apache.org/repos/asf/creadur/rat/trunk/
+svn co https://svn.apache.org/repos/asf/creadur/rat/trunk/
 +------------------------------------------+
 
- Build with {{{http://maven.apache.org/} Apache Maven}}
+ Build with {{{https://maven.apache.org/} Apache Maven}}
 
 +------------------------------------------+
 mvn install
diff --git a/apache-rat-plugin/src/main/resources/org/apache/rat/mp/package.html b/apache-rat-plugin/src/main/resources/org/apache/rat/mp/package.html
index f80d317..5b1f798 100644
--- a/apache-rat-plugin/src/main/resources/org/apache/rat/mp/package.html
+++ b/apache-rat-plugin/src/main/resources/org/apache/rat/mp/package.html
@@ -24,6 +24,6 @@
 </head>
 <body>
 This package contains the Rat plugins for
-<a href="http://maven.apache.org">Maven 2</a>.
+<a href="https://maven.apache.org">Maven</a>.
 </body>
 </html>
diff --git a/apache-rat-plugin/src/site/apt/index.apt b/apache-rat-plugin/src/site/apt/index.apt
index d2f9058..84443f0 100644
--- a/apache-rat-plugin/src/site/apt/index.apt
+++ b/apache-rat-plugin/src/site/apt/index.apt
@@ -23,7 +23,7 @@
   This plugin may be used to run Rat, the
   {{{../index.html}Release Audit Tool}}. It
   verifies, whether your source code matches standards like the
-  {{{http://www.apache.org/legal/src-headers.html}ASF Source Header
+  {{{https://www.apache.org/legal/src-headers.html}ASF Source Header
   and Copyright Notice Policy}}.
 
 * Goals Overview
diff --git a/apache-rat-plugin/src/site/fml/faq.fml b/apache-rat-plugin/src/site/fml/faq.fml
index f46cdfb..7ef1530 100644
--- a/apache-rat-plugin/src/site/fml/faq.fml
+++ b/apache-rat-plugin/src/site/fml/faq.fml
@@ -25,9 +25,9 @@
           whether you're source files are carrying proper
           license headers. Almost any non-trivial organization
           has a policy for license headers. In the case
-          of the <a href="http://www.apache.org/">Apache Software
+          of the <a href="https://www.apache.org/">Apache Software
           Foundation (ASF)</a>, this is the
-          <a href="http://www.apache.org/legal/src-headers.html">ASF
+          <a href="https://www.apache.org/legal/src-headers.html">ASF
           Source Header and Copyright Notice Policy</a>.
         </p>
       </answer>
@@ -37,7 +37,7 @@
       <answer>
         <p>
           Apache Rat is now part of the 
-          <a href='http://creadur.apache.org'>Apache Creadur</a> project,
+          <a href='https://creadur.apache.org'>Apache Creadur</a> project,
           a home for all sorts of software that helps audit and review
           software distributions.
         </p>
diff --git a/apache-rat-tasks/src/site/apt/examples/custom.apt b/apache-rat-tasks/src/site/apt/examples/custom.apt
index acf5e11..d27eded 100644
--- a/apache-rat-tasks/src/site/apt/examples/custom.apt
+++ b/apache-rat-tasks/src/site/apt/examples/custom.apt
@@ -30,7 +30,7 @@
  configuration of your instance via XML attributes or nested elements
  your type must provide methods that follow Ant's method naming
  conventions.  For details see the
- {{{http://ant.apache.org/manual/develop.html#writingowntask} Writing
+ {{{https://ant.apache.org/manual/develop.html#writingowntask} Writing
  Your Own Task}} section in Ant's manual.
 
  For this example let us assume you want to match a license that looks
@@ -96,8 +96,8 @@
 
  In order to use your matcher it has to be defined as an Ant type.
  You do so by either using
- {{{http://ant.apache.org/manual/Tasks/typedef.html} <<<typedef>>>}} or
- {{{http://ant.apache.org/manual/Tasks/componentdef.html}
+ {{{https://ant.apache.org/manual/Tasks/typedef.html} <<<typedef>>>}} or
+ {{{https://ant.apache.org/manual/Tasks/componentdef.html}
  <<<componentdef>>>}}.  If you are using Ant 1.8.x you should use
  <<<componentdef>>>.
 
diff --git a/apache-rat-tasks/src/site/apt/index.apt b/apache-rat-tasks/src/site/apt/index.apt
index 0d1ce30..b26d84f 100644
--- a/apache-rat-tasks/src/site/apt/index.apt
+++ b/apache-rat-tasks/src/site/apt/index.apt
@@ -23,7 +23,7 @@
 
  The Ant Task Library provides a single Ant task and a few supporting
  Ant types to run Rat, the {{{../index.html}Release Audit Tool}}, from
- inside {{{http://ant.apache.org/}Apache Ant}}.
+ inside {{{https://ant.apache.org/}Apache Ant}}.
 
  Using Ant's resource abstraction the task can be used to check files
  on disk as well as tarballs or even URLs directly.
diff --git a/apache-rat-tasks/src/site/apt/report.apt b/apache-rat-tasks/src/site/apt/report.apt
index 0086a4b..315cf2f 100644
--- a/apache-rat-tasks/src/site/apt/report.apt
+++ b/apache-rat-tasks/src/site/apt/report.apt
@@ -25,7 +25,7 @@
   runs Rat on a given set of resources and generates the report.
 
   The task can work on any Ant
-  {{{http://ant.apache.org/manual/Types/resources.html}resource or
+  {{{https://ant.apache.org/manual/Types/resources.html}resource or
   resource collection}} and the usual Ant selectors can be applied to
   restrict things even further.
 
@@ -63,9 +63,9 @@
 * Resources
 
   The files to be checked by Rat are specified as nested
-  {{{http://ant.apache.org/manual/Types/resources.html} resource
+  {{{https://ant.apache.org/manual/Types/resources.html} resource
   (collection)(s)}}, the most basic one would probably be a
-  {{{http://ant.apache.org/manual/Types/fileset.html} fileset}}.
+  {{{https://ant.apache.org/manual/Types/fileset.html} fileset}}.
 
   For example the following would check all Java files in the
   <<<src>>> directory.
diff --git a/apache-rat-tasks/src/site/apt/types.apt b/apache-rat-tasks/src/site/apt/types.apt
index 54d0bfe..3ec1fc6 100644
--- a/apache-rat-tasks/src/site/apt/types.apt
+++ b/apache-rat-tasks/src/site/apt/types.apt
@@ -26,9 +26,9 @@
  license families.
 
  In order to stay compatible with Ant 1.7.1 these types are defined
- via {{{http://ant.apache.org/manual/Tasks/typedef.html}
+ via {{{https://ant.apache.org/manual/Tasks/typedef.html}
  <<<typedef>>>}} rather than
- {{{http://ant.apache.org/manual/Tasks/componentdef.html}
+ {{{https://ant.apache.org/manual/Tasks/componentdef.html}
  <<<componentdef>>>}} which means they can be defined outside of the
  Report task as well - but they will be completely useless there.
 
diff --git a/apache-rat/README.txt b/apache-rat/README.txt
index 66cae99..37633de 100644
--- a/apache-rat/README.txt
+++ b/apache-rat/README.txt
@@ -12,7 +12,7 @@
 
 For more details, please see the file README-CLI.txt or the website:
 
-http://creadur.apache.org/rat/apache-rat/index.html
+https://creadur.apache.org/rat/apache-rat/index.html
 
 Apache Rat Ant Task Library
 ===========================
@@ -23,4 +23,4 @@
 
 For more details, please see the file README-ANT.txt or the website:
 
-http://creadur.apache.org/rat/apache-rat-tasks/index.html
\ No newline at end of file
+https://creadur.apache.org/rat/apache-rat-tasks/index.html
\ No newline at end of file
diff --git a/apache-rat/src/site/apt/index.apt.vm b/apache-rat/src/site/apt/index.apt.vm
index 03226d0..1d73b97 100644
--- a/apache-rat/src/site/apt/index.apt.vm
+++ b/apache-rat/src/site/apt/index.apt.vm
@@ -23,8 +23,8 @@
 
  Rat audits software distributions, with a special interest in headers.
  If this isn't quite what you're looking for then take a look at the
- other products developed by {{{http://creadur.apache.org}Apache Creadur}}&#8482;,
- including {{{http://creadur.apache.org/whisker}Apache Whisker}}&#8482; which audits
+ other products developed by {{{https://creadur.apache.org}Apache Creadur}}&#8482;,
+ including {{{https://creadur.apache.org/whisker}Apache Whisker}}&#8482; which audits
  and generates legal (for example <<<LICENSE>>>) documents for
  complex software distributions.
 
diff --git a/pom.xml b/pom.xml
index 18ad897..cdf7468 100644
--- a/pom.xml
+++ b/pom.xml
@@ -534,13 +534,13 @@
       <subscribe>dev-subscribe@creadur.apache.org</subscribe>
       <unsubscribe>dev-unsubscribe@creadur.apache.org</unsubscribe>
       <post>dev@creadur.apache.org</post>
-      <archive>http://mail-archives.apache.org/mod_mbox/creadur-dev/</archive>
+      <archive>https://mail-archives.apache.org/mod_mbox/creadur-dev/</archive>
     </mailingList>
     <mailingList>
       <name>Rat Commits (Apache Creadur project)</name>
       <subscribe>commits-subscribe@creadur.apache.org</subscribe>
       <unsubscribe>commits-unsubscribe@creadur.apache.org</unsubscribe>
-      <archive>http://mail-archives.apache.org/mod_mbox/creadur-commits/</archive>
+      <archive>https://mail-archives.apache.org/mod_mbox/creadur-commits/</archive>
     </mailingList>
   </mailingLists>
   <developers>
diff --git a/src/changes/release-notes.vm b/src/changes/release-notes.vm
index 8298b71..a008aee 100644
--- a/src/changes/release-notes.vm
+++ b/src/changes/release-notes.vm
@@ -24,7 +24,7 @@
 ").replaceAll("(?m)^ +","")
 
 ## N.B. the available variables are described here:
-## http://maven.apache.org/plugins/maven-changes-plugin/examples/using-a-custom-announcement-template.html
+## https://maven.apache.org/plugins/maven-changes-plugin/examples/using-a-custom-announcement-template.html
 ##
 ## Hack to improve layout: replace all pairs of spaces with a single new-line
 $release.description.replaceAll("  ", "
diff --git a/src/site/apt/index.apt.vm b/src/site/apt/index.apt.vm
index ec4fd5d..f3a9867 100644
--- a/src/site/apt/index.apt.vm
+++ b/src/site/apt/index.apt.vm
@@ -38,7 +38,7 @@
 
 ** Why Develop Rat?
 
- Reviewing releases in the {{{http://incubator.apache.org/}Apache Incubator}}
+ Reviewing releases in the {{{https://incubator.apache.org/}Apache Incubator}}
  by hand was error-prone and time-consuming.
 
  Rat arises from the Apache style, but is used more widely.
@@ -69,7 +69,7 @@
   Apache Rat is part of the {{{https://creadur.apache.org}Apache Creadur}}
   language- and build-agnostic suite of tools for auditing and comprehending
   software distributions. Our community develops
-  {{{http://www.opensource.org/} open source software}} the
+  {{{https://opensource.org/} open source software}} the
   {{{https://www.apache.org/foundation/how-it-works.html} Apache way}}.
 
   Please feel free to contribute a
@@ -117,7 +117,7 @@
   Quick start
 
 +------------------------------------------+
-svn co http://svn.apache.org/repos/asf/creadur/rat/trunk/
+svn co https://svn.apache.org/repos/asf/creadur/rat/trunk/
 +------------------------------------------+
 
  Read more {{{./source-repository.html}here}}.
diff --git a/src/site/xdoc/download_rat.xml.vm b/src/site/xdoc/download_rat.xml.vm
index 6c337d1..abbc0d7 100644
--- a/src/site/xdoc/download_rat.xml.vm
+++ b/src/site/xdoc/download_rat.xml.vm
@@ -88,7 +88,7 @@
               <td><a href="[preferred]/creadur/apache-rat-${previousRatVersion}/apache-rat-${previousRatVersion}-bin.zip">apache-rat-${previousRatVersion}-bin.zip</a></td>
               <td><a href="https://www.apache.org/dist/creadur/apache-rat-${previousRatVersion}/apache-rat-${previousRatVersion}-bin.zip.md5">md5</a></td>
               <td><a href="https://www.apache.org/dist/creadur/apache-rat-${previousRatVersion}/apache-rat-${previousRatVersion}-bin.zip.sha1">sha1</a></td>
-              <td><a href="http://www.apache.org/dist/creadur/apache-rat-${previousRatVersion}/apache-rat-${previousRatVersion}-bin.zip.asc">pgp</a></td>
+              <td><a href="https://www.apache.org/dist/creadur/apache-rat-${previousRatVersion}/apache-rat-${previousRatVersion}-bin.zip.asc">pgp</a></td>
           </tr>
         </table>
       </subsection>
