diff --git a/src/rules/converters/ban.ts b/src/rules/converters/ban.ts
new file mode 100644
index 00000000..586765fb
--- /dev/null
+++ b/src/rules/converters/ban.ts
@@ -0,0 +1,67 @@
+import { RuleConverter } from "../converter";
+
+type BanRule = {
+    object?: string;
+    property?: string;
+    message?: string;
+};
+
+export const convertBan: RuleConverter = tslintRule => {
+    let bannedObjMethod: BanRule[] = [];
+
+    for (const rule of tslintRule.ruleArguments) {
+        switch (rule.constructor.name) {
+            case "String":
+                bannedObjMethod.push({
+                    property: rule,
+                });
+                break;
+            case "Array":
+                if (rule.length == 1) {
+                    bannedObjMethod.push({
+                        property: rule[0],
+                    });
+                } else {
+                    bannedObjMethod.push({
+                        object: rule[0],
+                        property: rule[1],
+                        ...{ message: rule[2] ? rule[2] : undefined },
+                    });
+                }
+                break;
+            case "Object":
+                if (Array.isArray(rule.name)) {
+                    if (rule.name.length == 2) {
+                        // TODO: Fix iteration if multiple properties.
+                        bannedObjMethod.push({
+                            ...{ object: rule.name[0] !== "*" ? rule.name[0] : undefined },
+                            property: rule.name[1],
+                            ...{ message: rule.message ? rule.message : undefined },
+                        });
+                    } else {
+                        // Don't know how to deal with nested functions.
+                    }
+                } else {
+                    bannedObjMethod.push({
+                        property: rule.name,
+                        ...{ message: rule.message ? rule.message : undefined },
+                    });
+                }
+                break;
+            default:
+                break;
+        }
+    }
+
+    const ruleArguments =
+        tslintRule.ruleArguments.length === 0 ? undefined : [2, ...bannedObjMethod];
+
+    return {
+        rules: [
+            {
+                ruleName: "no-restricted-properties",
+                ...{ ruleArguments },
+            },
+        ],
+    };
+};
diff --git a/src/rules/converters/tests/ban.test.ts b/src/rules/converters/tests/ban.test.ts
new file mode 100644
index 00000000..1e961573
--- /dev/null
+++ b/src/rules/converters/tests/ban.test.ts
@@ -0,0 +1,142 @@
+import { convertBan } from "../ban";
+
+describe(convertBan, () => {
+    test("conversion without arguments", () => {
+        const result = convertBan({
+            ruleArguments: [],
+        });
+
+        expect(result).toEqual({
+            rules: [
+                {
+                    ruleName: "no-restricted-properties",
+                },
+            ],
+        });
+    });
+
+    test("conversion with single string argument", () => {
+        const result = convertBan({
+            ruleArguments: [true, "eval"],
+        });
+
+        expect(result).toEqual({
+            rules: [
+                {
+                    ruleName: "no-restricted-properties",
+                    ruleArguments: [
+                        2,
+                        {
+                            property: "eval",
+                        },
+                    ],
+                },
+            ],
+        });
+    });
+
+    test("conversion with single array argument", () => {
+        const result = convertBan({
+            ruleArguments: [true, ["map"]],
+        });
+
+        expect(result).toEqual({
+            rules: [
+                {
+                    ruleName: "no-restricted-properties",
+                    ruleArguments: [
+                        2,
+                        {
+                            property: "map",
+                        },
+                    ],
+                },
+            ],
+        });
+    });
+
+    test("conversion with array argument but no message", () => {
+        const result = convertBan({
+            ruleArguments: [true, ["describe", "only"]],
+        });
+
+        expect(result).toEqual({
+            rules: [
+                {
+                    ruleName: "no-restricted-properties",
+                    ruleArguments: [
+                        2,
+                        {
+                            object: "describe",
+                            property: "only",
+                        },
+                    ],
+                },
+            ],
+        });
+    });
+
+    test("conversion with array argument and message", () => {
+        const result = convertBan({
+            ruleArguments: [true, ["describe", "only", "use another method"]],
+        });
+
+        expect(result).toEqual({
+            rules: [
+                {
+                    ruleName: "no-restricted-properties",
+                    ruleArguments: [
+                        2,
+                        {
+                            object: "describe",
+                            property: "only",
+                            message: "use another method",
+                        },
+                    ],
+                },
+            ],
+        });
+    });
+
+    test("conversion with object argument and property name as string but no message", () => {
+        const result = convertBan({
+            ruleArguments: [true, { name: "$" }],
+        });
+
+        expect(result).toEqual({
+            rules: [
+                {
+                    ruleName: "no-restricted-properties",
+                    ruleArguments: [
+                        2,
+                        {
+                            property: "$",
+                        },
+                    ],
+                },
+            ],
+        });
+    });
+
+    test("conversion with object argument and property name as array and message", () => {
+        const result = convertBan({
+            ruleArguments: [true, { name: ["it", "only"], message: "do not focus tests" }],
+        });
+
+        expect(result).toEqual({
+            rules: [
+                {
+                    ruleName: "no-restricted-properties",
+                    ruleArguments: [
+                        2,
+                        {
+                            object: "it",
+                            property: "only",
+                            message: "do not focus tests",
+                        },
+                    ],
+                },
+            ],
+        });
+    });
+});
diff --git a/src/rules/rulesConverters.ts b/src/rules/rulesConverters.ts
index 4ac20ea8..4e3cbc70 100644
--- a/src/rules/rulesConverters.ts
+++ b/src/rules/rulesConverters.ts
@@ -4,6 +4,7 @@ import { convertArrayType } from "./converters/array-type";
 import { convertArrowParens } from "./converters/arrow-parens";
 import { convertArrowReturnShorthand } from "./converters/arrow-return-shorthand";
 import { convertAwaitPromise } from "./converters/await-promise";
+import { convertBan } from "./converters/ban";
 import { convertBanCommaOperator } from "./converters/ban-comma-operator";
 import { convertBanTsIgnore } from "./converters/ban-ts-ignore";
 import { convertBanTypes } from "./converters/ban-types";
@@ -142,6 +143,7 @@ export const rulesConverters = new Map([
     ["arrow-parens", convertArrowParens],
     ["arrow-return-shorthand", convertArrowReturnShorthand],
     ["await-promise", convertAwaitPromise],
+    ["ban", convertBan], // no-restricted-properties
     ["ban-comma-operator", convertBanCommaOperator],
     ["ban-ts-ignore", convertBanTsIgnore],
     ["ban-types", convertBanTypes],
@@ -276,7 +278,6 @@ export const rulesConverters = new Map([
     // As these are enabled, they should be added in sorted order to the list above.
 
     // TSLint core rules:
-    // ["ban", convertBan], // no-restricted-properties
 
     // tslint-microsoft-contrib rules:
     // ["max-func-body-length", convertMaxFuncBodyLength],